Mobile MCP: AI-driven automation across iOS and Android devices
An MCP server for AI clients to operate iOS and Android apps using the accessibility tree instead of screenshot-only automation.
GitHub mobile-next/mobile-mcp Updated 2026-09-27 Branch main Stars 7.4K Forks 641
TypeScript MCP Server Mobile Automation iOS Android Simulators and Real Devices

🧭 Decision Guide

Why trending now: Cannot be determined from the provided material.

Try it if you

  • You need Claude Code, Cursor, or Codex to execute mobile UI workflows across iOS and Android.
    The README says “Works with Claude Code, Codex, Gemini, GitHub Copilot...” and advertises “One API, every target.”
  • You have an iOS Simulator or Android Emulator and want to run mobile automation without a real device.
    The README section “Running in headless mode on Simulators/Emulators” describes running simulators or emulators in the background.
  • You want to read UI from the native accessibility tree instead of having a vision model process full screenshots.
    The README’s “Accessibility-first — fast and cheap” feature explicitly says “no vision model, no image tokens.”

Skip it if you

  • Your iOS environment lacks Xcode or cannot start the Simulator.
    The README’s “Running & configuration” section states that iOS requires Xcode and the Simulator must be running before use.
  • Your target app cannot expose accessibility elements and the workflow cannot tolerate screenshot-coordinate fallback.
    The README says the primary path is the native accessibility tree, with screenshots and coordinates used only as a fallback.
  • You require enterprise Authorization, Telemetry, or Streamable HTTP configuration not covered in the provided material.
    These sections are listed among the omitted README chapters, and their configuration details were not provided.

Requirements

  • An MCP-compatible client is required; the README lists Claude Code, Codex, Gemini, and GitHub Copilot.
  • The standard configuration uses npx and @mobilenext/mobile-mcp@latest.
  • The iOS simulator requires Xcode, and the Simulator must be running before use.
  • Without a real device, an Android emulator or iOS simulator can run in the background.

First step (verbatim from README)

xcrun simctl list

Watch out

  • Confirm the iOS simulator name and state with xcrun simctl list before using the boot command.
    The README’s Running & configuration section lists xcrun simctl list followed by xcrun simctl boot "iPhone 16".
  • Screenshot coordinates are only a fallback path and are not equivalent to structured accessibility output.
    The README states that the accessibility tree is the primary path and screenshots plus coordinates are used only when needed.
  • Using @latest makes the configuration follow the latest npm package, while the latest listed release is Version 1.0.4.
    The installation configuration uses @mobilenext/mobile-mcp@latest, while project metadata lists Version 1.0.4 as the latest release.

Alternatives

  • XCUITest：It may be preferable when the team explicitly needs an iOS-native testing framework rather than MCP-client control; the README names XCUITest as a platform-specific approach Mobile MCP avoids.
    Main Features
  • Espresso：It may be preferable when the team explicitly needs an Android-native testing framework rather than a unified mobile API; the README names Espresso as an approach Mobile MCP avoids.
    Main Features

Not stated in the README

  • The provided README material does not specify minimum Node.js, npm, Xcode, or Android SDK versions.
  • The provided material does not list the complete MCP tool names, parameters, return structures, or error-handling behavior.
  • The provided material does not define support boundaries for iOS and Android versions, device models, or app types.
  • The provided material does not detail real-device pairing, permissions, USB connections, or cloud-device setup.
  • The provided material does not provide Mobile Next Cloud pricing, regions, latency, or data-processing details.
  • The provided material does not explain screenshot-coordinate recognition rules or failure rates when the accessibility tree is unavailable.
  • The provided material does not state concurrent device counts, throughput, stability metrics, or CI integration details.
  • The provided material does not expand on Authorization, Telemetry, Environment variables, or Streamable HTTP Server Mode.
  • The provided material does not describe what changed in Version 1.0.4 from the previous release.

💡 Deep Analysis

6
No I maintain a long-running iOS/Android regression pipeline with the Codex CLI and require precise assertions, parallel device orchestration, complex fixtures, and stable CI reports. Can Mobile MCP alone replace XCUITest, Espresso, or a professional device farm?
For: A QA team maintaining a strict mobile regression pipeline with the Codex CLI that requires precise assertions, parallel device orchestration, complex fixtures, and stable long-term CI reports

No, not as the sole replacement for a complete regression infrastructure. The project insights explicitly state that Mobile MCP is not a full replacement for XCUITest, Espresso, or specialized testing frameworks.

  • The README emphasizes an agent-callable mobile control layer, structured UI reading, and natural-language workflows rather than a complete test-orchestration system.
  • The project insights specifically identify precise assertions, parallel device orchestration, complex fixtures, and stable CI reporting as areas that may still require dedicated tools.
  • When the accessibility tree is unavailable, the system falls back to screenshot coordinates; coordinates depend on resolution, orientation, and layout and should not be the only locator strategy for strict regression.
  • Mobile MCP is better positioned as an agent-driven exploration, acceptance, and end-to-end validation layer alongside existing code-based tests.
  • Project insights, usage_limitations: not a complete replacement for XCUITest, Espresso, or other specialized test frameworks
  • Project insights, usage_limitations: precise assertions, parallel device orchestration, complex fixtures, performance testing, and stable CI reports may still require dedicated tools
  • Main Features: structured deterministic output coexists with screenshot-coordinate fallback
  • Project insights, best_practices: retain traditional automation frameworks for strict assertions, parallel execution, or long-term regression
codex mcp add mobile-mcp npx "@mobilenext/mobile-mcp@latest"
Not stated in the README：The README excerpt does not state whether assertion APIs, JUnit/HTML reports, or CI plugins are provided.；It does not specify parallel-device limits, test isolation, retry behavior, or failure replay.；It does not explain the concrete integration pattern with XCUITest or Espresso.
Yes I use Claude Code for native iOS/Android end-to-end acceptance flows involving deep links, app installation and termination, orientation changes, hardware buttons, and screen recording. Can Mobile MCP cover these device-level actions?
For: A developer using Claude Code for mobile end-to-end acceptance who must cover deep links, app installation/termination, orientation, hardware buttons, and screen recording rather than simple click regression

Yes. The README’s Full device control list directly covers most of the device-level actions in your acceptance flow.

  • The feature list includes app install/launch/terminate, covering lifecycle setup and cleanup.
  • It also lists screen recording, hardware buttons, deep links, and orientation, matching your requested steps one by one.
  • These capabilities are exposed through MCP to Claude Code, and the README provides a dedicated CLI registration command, so the integration path is explicit.
  • The excerpt does not specify deep-link argument formats for iOS versus Android, recording-file locations, the supported hardware-button set, or how recordings are linked automatically to acceptance results.
  • Main Features: “Full device control: taps, swipes, and gestures; app install/launch/terminate; screen recording; hardware buttons; deep links; orientation”
  • Claude Code installation section: Use the Claude Code CLI to add the Mobile MCP server
  • The Available MCP Tools section is listed but omitted from the excerpt
claude mcp add mobile-mcp -- npx -y @mobilenext/mobile-mcp@latest
Not stated in the README：The README excerpt does not provide concrete parameters for deep links, hardware buttons, or screen recording.；It does not specify the output format, storage location, or retention lifecycle for recordings, logs, and crash reports.
Yes I need Claude Code to validate an iOS Simulator, an Android Emulator, and physical devices without maintaining separate XCUITest, Espresso, and platform glue code. Is Mobile MCP suitable?
For: A mobile QA engineer maintaining native iOS and Android apps with Claude Code, covering simulators and real devices, and trying to avoid separate XCUITest and Espresso scripts

Yes, because it is explicitly designed to expose one MCP tool surface across iOS, Android, simulators, emulators, and real devices.

  • The README states “One API, every target,” with the same tools for iOS and Android device types.
  • “No platform expertise required” specifically removes the need for XCUITest, Espresso, and per-platform glue code.
  • The tools cover UI reading, taps, swipes, text input, app install/launch/termination, orientation, and hardware buttons.
  • Results still depend on the app exposing a usable accessibility tree. Custom-drawn controls or missing accessibility properties may force screenshot and coordinate fallback, which can be less stable.
  • Main Features: “One API, every target”
  • Main Features: “No platform expertise required: no XCUITest, no Espresso, no per-platform glue”
  • Main Features: “Full device control”
  • README: structured accessibility snapshots or coordinate-based taps based on screenshots
claude mcp add mobile-mcp -- npx -y @mobilenext/mobile-mcp@latest
Not stated in the README：The README does not provide a compatibility matrix for specific iOS/Android versions or physical device models.；It does not specify assertion syntax, parallel device limits, or CI orchestration capabilities for cross-platform workflows.
Yes I only have a headless Android Emulator running locally and use the Codex CLI. Can Mobile MCP let the agent launch an app, read structured UI state, and fill forms, and where should I start?
For: An Android developer using the Codex CLI who can only run an Android Emulator headlessly on the local machine and wants natural-language app launch, UI reading, and form input

Yes. The README explicitly covers Android Emulators, local execution, and structured UI interaction, matching your constraints.

  • “Accessibility-first” means the server reads the native accessibility tree before using vision or image tokens, which is suitable for identifying form fields and page state.
  • “Full device control” includes app launch, taps, text input, and gestures.
  • The Running in “headless” mode section says that, without a real device, Mobile MCP can run against an emulator in the background; the emulator must be started first.
  • The provided excerpt does not include the complete Android Emulator launch command, nor does it explain how to configure your package name, permission dialogs, or test credentials.
  • Main Features: “Accessibility-first — fast and cheap”
  • Main Features: “Full device control: taps, swipes, and gestures; app install/launch/terminate”
  • Running & configuration: “Running in ‘headless’ mode on Simulators/Emulators”
  • How to Use: instruct the AI assistant to use the available tools
codex mcp add mobile-mcp npx "@mobilenext/mobile-mcp@latest"
Not stated in the README：The excerpt does not provide the complete avdmanager/emulator command for starting an Android Emulator.；The README does not explain form assertions, permission-dialog handling, or credential injection.
Yes I use Cursor Agent for iOS and Android native UI acceptance. I want results to come from accessibility snapshots rather than repeated vision-model calls, while still allowing coordinate fallback for custom-drawn controls. Does Mobile MCP fit this strategy?
For: A mobile QA engineer using Cursor Agent for cross-platform UI acceptance, requiring structured accessibility snapshots first and allowing screenshot-coordinate fallback only when necessary

Yes. The README explicitly uses a two-path strategy: accessibility-tree-first interaction with screenshot-and-coordinate fallback, rather than relying entirely on visual recognition.

  • The Accessibility-first feature states that it avoids vision models and image tokens, reducing screenshot-recognition cost.
  • The server reads native iOS/Android UI through structured accessibility snapshots, producing information more suitable for agent consumption than screenshots alone.
  • When the accessibility tree is insufficient, the README supports coordinate-based taps derived from screenshots, which can cover some custom or non-standard controls.
  • The tradeoff is that fallback coordinates depend on screen size, orientation, and layout; the README does not promise identical stability across device configurations.
  • Main Features: “Accessibility-first — fast and cheap”
  • Introduction: structured accessibility snapshots or coordinate-based taps based on screenshots
  • Main Features: “Structured, deterministic output”
  • Project insight: accessibility-tree-first with screenshot-coordinate fallback
npx -y @mobilenext/mobile-mcp@latest
Not stated in the README：The README does not explain how Cursor Agent selects structured versus coordinate targeting or list the tool parameters.；It does not define the support boundaries for custom Canvas, game interfaces, or complex gestures.
It depends I use the Gemini CLI. Our team does not want to configure Xcode, the Android SDK, and USB-connected devices on every workstation, but we need to operate real iOS/Android devices in the cloud. Is Mobile MCP suitable for this deployment model?
For: An automation engineer using the Gemini CLI who needs cloud real devices without preparing local iOS/Android devices and wants to reuse the same MCP tools for app acceptance

It depends. Mobile Next Cloud can remove much of the local device setup, but suitability still depends on cloud authorization, network behavior, cost, and data-compliance requirements.

  • The README explicitly supports connecting to real iOS and Android devices through Mobile Next Cloud and describes this as “same tools, no local setup.”
  • Local and cloud devices use the same MCP tool interface, so a Gemini CLI workflow can move from local devices to remote devices without changing the conceptual tool surface.
  • The project description covers real devices, simulators, and emulators, indicating broad device-form support.
  • However, the excerpt does not specify cloud plans, concurrency, regions, latency, app-upload procedures, or enterprise data isolation. Those details determine whether it satisfies the deployment constraint.
  • Introduction: run it against real iOS and Android devices in the cloud with Mobile Next Cloud — same tools, no local setup
  • README title: iOS, Android, Simulator, Emulator, and Real Devices
  • The Remote Devices (Mobile Next Cloud) section is listed but omitted from the excerpt
  • Project description: Model Context Protocol Server for Mobile Automation and Scraping
gemini mcp add mobile-mcp npx -y @mobilenext/mobile-mcp@latest
Not stated in the README：The README excerpt does not state Mobile Next Cloud pricing, concurrency limits, regions, or network latency.；It does not explain remote app upload, signing, account isolation, log retention, or privacy-compliance mechanisms.

✨ Highlights

  • Accessibility-tree first, avoiding vision models and image tokens
  • One API covers iOS, Android, emulators, simulators, and real devices
  • Supports taps, gestures, app management, recording, and deep links
  • Structured accessibility snapshots reduce screenshot-automation ambiguity
  • The project has 7,351 stars but only 10 contributors and 5 releases

🔧 Engineering

  • The MCP Server lets Claude Code, Codex, and other clients operate mobile apps
  • Accessibility snapshots read native UI elements and extract structured data
  • A unified interface supports iOS, Android, simulators, emulators, and real devices
  • Device control covers installation, launch, termination, recording, orientation, and hardware buttons

⚠️ Risks

  • When native accessibility nodes are unavailable, it falls back to screenshots and coordinates
  • Running an iOS simulator explicitly requires Xcode and a started Simulator
  • The provided README material omits the full Prerequisites and Platform Support sections
  • The provided material does not detail real-device, cloud-device, or Authorization configuration

👥 For who?

  • Teams testing mobile UI workflows with Claude Code, Cursor, or Codex
  • Automation engineers needing one API across iOS and Android device matrices
  • Mobile developers who already have Xcode Simulator or Android Emulator available