Model or dataset
mobile-next/mobile-mcp avatar
mobile-next/mobile-mcp

mobile-mcp: an MCP server that drives iOS and Android from the accessibility tree

Model Context Protocol Server for Mobile Automation and Scraping (iOS, Android, Emulators, Simulators and Real Devices)

10,589 stars944 forksTypeScriptApache-2.0

At a glance

What is it?
mobile-next/mobile-mcp exposes one set of MCP tools for simulators, emulators and real phones, reading the native accessibility tree first and falling back to screenshots. It removes per-platform test glue, but it also removes the deterministic assertions that glue used to give you.
Who is it for?
Adopt mobile-mcp if you already run an MCP-capable agent (Claude Code, Codex, Gemini, GitHub Copilot, Antigravity) and want it to operate a booted simulator or an adb-authorized phone without writing XCUITest or Espresso. Do not adopt it as a replacement for a deterministic regression suite, and do not expect it to work on a machine without Xcode or the Android SDK.
Can I use it commercially?
Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 4 days ago.
What is it written in?
Mainly TypeScript, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • mobile-next/mobile-mcp10,589 ★ · +3,910
Star history
Repository2026-09-132026-11-15
mobile-next/mobile-mcp6.7k10.6k

3,910 Stars in the last 63 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The glue code mobile-mcp deletes, and who was writing it

Automating a phone normally means picking a side. On iOS that means XCUITest and the XCTest runner; on Android it means Espresso or UiAutomator. A team that wants one scripted flow to run on an iPhone and a Pixel writes it twice, in two languages, against two element-query APIs. mobile-mcp's README states the goal directly: a platform-agnostic interface that eliminates the need for distinct iOS or Android knowledge. The audience is not the QA engineer who already maintains an Appium suite. It is the person wiring an LLM agent to a device, where the caller is a model that can read a list of elements and decide what to tap next. The README lists the intended cases: native app automation for testing or data entry, scripted form flows without manually driving a simulator, multi-step journeys driven by an LLM, and data extraction. Every one of those assumes a human describes a goal rather than writes a selector.

Accessibility tree first, screenshots as the fallback

The mechanism the README describes is a two-tier read of the screen. The primary path is the native accessibility tree, which the project frames as fast and cheap because it sends no image tokens to the model. The fallback is a screenshot plus coordinate taps. That distinction matters more than it sounds. A screenshot-based agent pays for every pixel it looks at and can only guess where a button is; an accessibility snapshot returns named elements with coordinates and properties attached. The tool that exposes this is `mobile_list_elements_on_screen`, which the README says lists UI elements with their coordinates and properties. When the tree is not enough, `mobile_click_on_screen_at_coordinates`, `mobile_double_tap_on_screen`, `mobile_long_press_on_screen_at_coordinates` and `mobile_swipe_on_screen` act on raw positions. The data flow is therefore: agent asks for elements, gets a structured list, picks one, acts on it, asks again.

One tool surface across four target types

The platform support table lists four targets: iOS Simulator (Xcode plus a booted simulator via `xcrun simctl`), iOS Real Device (connected over USB and trusted), Android Emulator (Android SDK plus a running emulator via `adb`), and Android Real Device (`adb` plus USB debugging enabled and authorized). The same tool names apply to all four. Device management covers `mobile_list_available_devices`, `mobile_get_screen_size`, `mobile_get_orientation`, `mobile_set_orientation`, `mobile_set_location` and `mobile_clipboard`. App lifecycle is `mobile_list_apps`, `mobile_get_foreground_app`, `mobile_launch_app`, `mobile_terminate_app`, `mobile_install_app` (from .apk, .ipa, .app or .zip) and `mobile_uninstall_app`. Input covers hardware buttons and deep links. Screen recording is a start/stop pair. That is a wide surface, and it is the strongest argument for the project: a model that has learned these names once can point them at any of the four targets.

Getting it running, and the setup it assumes

The README does give the invocation. The VS Code install badge encodes a server definition with `command` set to `npx` and `args` set to `-y` and `@mobilenext/mobile-mcp@latest`, which is the same shape any MCP client config takes. The package name on npm is `@mobilenext/mobile-mcp`. Clients named as compatible are Claude Code, Codex, Gemini, GitHub Copilot and Antigravity, plus anything else speaking MCP. The environment has to provide the device tooling itself: `xcrun simctl` for iOS simulators, `adb` for Android. A second path exists for hardware you do not own: the cloud tools `mobile_login_to_cloud_provider`, `mobile_list_remote_devices`, `mobile_allocate_remote_device` and `mobile_release_remote_device`, where login is described as a browser-based device-code flow and allocation reserves a physical device for exclusive use. The README claims the same tools apply, with no local setup.

Where the accessibility-first bet breaks down

The fallback to coordinates is also the failure mode. When an app draws its own controls on a canvas, or ships without meaningful accessibility labels, `mobile_list_elements_on_screen` returns either nothing useful or a set of unlabeled boxes. The agent then behaves like any other screenshot-driven tool: it taps a position that was correct on the last frame and stops being correct after a scroll, a keyboard slide, or an animation. The second constraint is environmental rather than architectural. Because the server drives whatever `adb` and `xcrun simctl` can see, it inherits their limits: one USB cable per physical device, a trusted pairing prompt on iOS, USB debugging authorization on Android. A CI runner with no emulator, simulator or attached device cannot use the local path.

Appium and Maestro solve a different half of the problem

Appium is the obvious comparison and the difference is structural. Appium exposes a WebDriver endpoint and expects a test process to drive it with explicit selectors, waits and assertions; the test owns the control flow and the pass/fail decision. mobile-mcp exposes MCP tools and expects a model to own the control flow, deciding at each step what to read and where to tap. Appium also normalizes across platforms through driver plugins, whereas mobile-mcp normalizes by giving both platforms the same tool names and letting the accessibility layer do the translation. Maestro sits closer to mobile-mcp in spirit, using YAML flows with implicit waits and a simpler mental model, but its flows are still authored artifacts that run the same way every time. mobile-mcp's flows are not artifacts at all; they are whatever the agent decides this run. That is the trade: you gain tolerance for UI changes the agent can reason around, and you lose reproducibility. If you need a fixed assertion that a checkout total equals a specific value, Appium or Maestro is the better fit. If you need an agent to poke at an app it has never seen, mobile-mcp is aimed at exactly that.

Licence, release cadence and what a version bump costs you

The licence is Apache-2.0, which permits commercial use, modification and redistribution provided the licence and notices are preserved; that is a statement about the licence text, not legal advice, and anyone embedding the server in a shipped product should read the file rather than this paragraph. The latest releases are 1.0.16 on 2026-11-02, 1.0.15 on 2026-10-30 and 1.0.14 on 2026-10-26. The default branch is main and the repository is not archived. The practical consequence for adopters is that pinning matters. The VS Code badge uses `@mobilenext/mobile-mcp@latest`, which means an MCP client configured that way picks up whatever npm serves on the next start. Because the server's contract is the tool list a model sees, a version bump that renames or removes a tool changes agent behaviour without any code change on your side. Pinning to an explicit version in the client config avoids this. Beyond that, the maintenance cost is mostly environmental: keeping Xcode, the Android SDK and `adb` current on every machine that runs the server.

Who this is for, and what to check before you commit

Use mobile-mcp when the caller is an agent and the target is a device you can already reach with `adb` or `xcrun simctl`. That covers exploratory testing, data entry against a real app, scraping a screen that has no API, and multi-step journeys where the path is not known in advance. Skip it when you need a regression suite that produces the same verdict twice, when your app's controls are canvas-drawn with no accessibility labels, or when your build machines have no attached hardware and you have not signed up for the cloud path. The first thing to verify is mundane: run `mobile_list_available_devices` and confirm your simulator, emulator or phone appears, because every other tool depends on that discovery step. The second is to call `mobile_list_elements_on_screen` against your own app and read the output. If the elements you need are named and positioned, the accessibility-first path will carry the work. If they come back empty or generic, you are on the coordinate fallback, and the agent's reliability will be decided by the app's UI, not by this server.

Editorial conclusion

Adopt mobile-mcp if you already run an MCP-capable agent (Claude Code, Codex, Gemini, GitHub Copilot, Antigravity) and want it to operate a booted simulator or an adb-authorized phone without writing XCUITest or Espresso. Do not adopt it as a replacement for a deterministic regression suite, and do not expect it to work on a machine without Xcode or the Android SDK. Verify first that `mobile_list_available_devices` returns your target, then check how `mobile_list_elements_on_screen` labels the specific widgets you care about, because that output is what the agent will act on.

Frequently asked questions

What is mobile-mcp?

It is a Model Context Protocol server from Mobile Next that lets agents and LLMs interact with native iOS and Android apps and devices. It works against simulators, emulators and real devices, and it is platform-agnostic, so the same tools cover both platforms. Any MCP-compatible client can use it, including Claude Code, Codex, Gemini and GitHub Copilot.

How do I use mobile-mcp?

Run the server and connect it to an MCP client, then point it at a device that is already available. You need Xcode and a booted simulator for iOS, or the Android SDK with a running emulator or a USB-authorized real device. Inside a session you list devices, list on-screen elements, and click by element ref or coordinate.

Does mobile-mcp work with VS Code?

The project ships a VS Code install link that registers the server through the built-in MCP install flow, using npx with the package @mobilenext/mobile-mcp@latest. The repository also contains mcp.json, server.json, manifest.json, smithery.yaml and glama.json, which are the registration formats for other clients and registries.

Official sources

  1. License: Apache-2.0
  2. mobile-next/mobile-mcp on GitHub
  3. Project website
  4. README
  5. Releases
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/mobile-next-mobile-mcp.svg)](https://hysenlabs.com/projects/mobile-next-mobile-mcp)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/mobile-next-mobile-mcp.svg)](https://hysenlabs.com/projects/mobile-next-mobile-mcp)

Was this useful?