How to Use Appium Inspector to Inspect Mobile Apps

Appium Inspector is a graphical client for Appium. To inspect a mobile app, install the standalone Inspector, start an Appium server with the correct platform driver, connect Inspector to that server using matching server details and session capabilities, and start a session. Inspector then pairs the app screenshot with its page source so you can search for elements, inspect attributes, interact with the app, and try supported Appium commands. Exact capabilities and controls depend on the platform, driver, device, and installed versions. See the official Appium Inspector project for current downloads and setup information.

1. Understand what Inspector does

Inspector is a visual tool for exploring an application through Appium. Its screenshot helps you identify what is visible; its source and element tree help you investigate how the current screen is represented to the automation driver. You can search for elements and interact with them through supported controls. It is useful for discovering and checking candidate locators while developing an automation test. The Appium tools documentation describes these inspection and test-development capabilities.

Inspector does not make a locator stable by itself. An attribute may be missing, duplicated, generated dynamically, or different across platforms, app states, and driver versions. Treat a locator found in Inspector as a candidate: verify that it selects the intended element and remains suitable across the states and devices your tests cover.

2. Install Inspector and prepare Appium

The official project distributes Inspector as a standalone desktop application for macOS, Windows, and Linux, and as an Appium server plugin. For the standalone workflow, Appium server is installed and run separately. Check the current Inspector releases and its system requirements and installation documentation before installing; operating system support can change.

Route	Deployment model	Use it when
Standalone desktop app	Inspector runs as a local desktop application and connects to an Appium server.	You want a local GUI and can install the desktop distribution.
Appium server plugin	Inspector is installed as a plugin and used through the Appium server environment.	You prefer the server-integrated web interface and can follow the plugin’s current installation procedure.

To install the plugin, the Appium ecosystem documentation gives this command:

appium plugin install inspector

Follow the current plugin README and server instructions to enable and use it. The standalone app and plugin are different deployment routes; consult their current documentation for exact setup and requirements.

Do not use the old inspector.appiumpro.com website as an official Appium Inspector service. The project says that site is no longer related to the Appium team and directs users to the standalone app or plugin.

Prerequisites checklist

Install Appium and the platform driver that matches the app and device you plan to inspect.
Have an available Android device or emulator, or an iOS-family device or simulator that your driver setup supports.
Know how to identify the target app, such as its package or bundle identifier, or have the app file available if your workflow uses one.
Confirm the device, operating system, driver, and Appium versions meet their current requirements.
For a remote device or hosted session, obtain that provider’s current endpoint and required capabilities from its documentation.

Android and iOS setup is not interchangeable. Capability names, signing and device requirements, app identifiers, and driver configuration depend on the selected platform and driver. Use the current Inspector session documentation and the relevant driver documentation to determine exact values instead of copying a capability block intended for another platform.

3. Connect Inspector and start a session

Start the Appium server using the installation and driver setup appropriate for your environment. Keep its terminal or service log available while troubleshooting.
Open the standalone Inspector, or use the plugin route you installed.
Enter the server host, port, and base path that match the running server. Defaults can differ between setups, so use the values your server actually reports or expects.
Build a session configuration for the target platform. Set the platform name and any relevant platform version, the automation driver, the device or simulator identifier, and the app path or app identifier required by that driver and workflow.
Check that capability names and values are accepted by your installed driver and any device provider. Do not assume a capability supported by one driver or provider will work with another.
Start the session. If it succeeds, Inspector should show the active app’s screenshot and source. If it fails, use the server log and troubleshooting table below to locate the failing layer.

Inspector’s session header is where you supply server details and session capabilities. Some visible controls are driver, OS, or device specific. For example, the official header documentation describes controls for UiAutomator2, Espresso, and XCUITest; check the current session header documentation for applicable requirements and controls. Avoid relying on a fixed capability example copied from an older guide: driver behavior and required values can change.

4. Find and validate an element locator

Navigate the app to the exact screen and state where the target element appears. A page source describes the current state, not every possible screen in the app.
Refresh or retrieve the current source and compare the screenshot with the element tree to identify the relevant node.
Search the source or use Inspector’s element search to narrow down candidates. Inspect the candidate’s available attributes, such as its visible label, accessibility identifier, resource identifier, or class, when provided by the platform and driver.
Select the candidate and confirm that Inspector highlights or otherwise identifies the same control you meant to inspect.
Try the supported interaction, such as tapping or sending text, if appropriate. Confirm that the app responds as expected and that the selected element is not an adjacent or hidden control.
Put the chosen locator into a small test and verify it against the real session. Prefer an app-provided stable accessibility identifier when one exists and is suitable; otherwise select the clearest unique attribute supported by your driver.

There is no universal locator priority that works for every app. A visible text value can change with localization or content; an element index or generated class may change with layout or app updates; an accessibility identifier may be absent or duplicated. If a search returns multiple matches, narrow the locator using a stable parent or additional attributes and verify the result rather than selecting the first match blindly.

What to record for a useful locator

The locator strategy and exact value.
The platform, driver, device or simulator, and app state where it was found.
Whether the locator is unique and what happens if the target is absent.
Any prerequisite navigation or wait needed before querying it.
Whether the attribute is app-defined and expected to stay stable across releases.

5. Use the screenshot, source, controls, and commands

The screenshot and hierarchy answer different questions. Use the screenshot to judge visual position and app state. Use source and element attributes to understand what the driver can locate. A visual control can be represented differently in the hierarchy, and a hierarchy node does not prove that a control is visible, enabled, or ready to receive an action.

Inspector can interact with the screenshot, search for elements, and run Appium driver commands. Available device buttons and controls vary by driver and platform. A control shown for Android may not exist for an iOS-family session, and some controls require particular driver or OS versions. Check the header documentation for the current requirements; do not infer support just from the control appearing in a different session.

The Commands tab is also contextual. Its available commands depend on the active driver and plugins, and Inspector issues them through WebdriverIO. The command list is limited by the commands WebdriverIO supports; a driver command missing from the tab may need another Appium client or supported route. See the Commands tab documentation before assuming a missing command is an Inspector or driver defect.

6. Troubleshoot common problems

Symptom	Likely cause	What to check or fix
Inspector cannot connect to the server	Appium is stopped, or host, port, or base path does not match the running server.	Confirm the server is running and inspect its startup output. Copy the actual endpoint and path into Inspector; check local networking and any proxy or firewall between Inspector and a remote server.
Session creation fails	Capability is unsupported, misspelled, incompatible, or incomplete for the selected driver, device, or provider.	Read the session creation error in the Appium log. Confirm platform name, driver, device identifier, app location or identifier, and platform-specific requirements against current driver documentation.
Driver not found or session reports an unknown driver	The required platform driver is not installed or is not available to the Appium server instance being used.	Install the appropriate driver using the current Appium instructions, then restart or reconnect to the server as required by that setup.
Device or simulator is not available	The device is disconnected, unavailable to the host, not booted, or identified differently than the capability expects.	Verify the device is visible and ready using the platform’s tools, then use the identifier required by the driver. For hosted devices, check the provider’s current connection details.
Screenshot appears but source is empty or incomplete	The app state may still be loading, the source request may have failed, or the driver exposes a different hierarchy than expected.	Wait for the screen to settle and refresh source. Check server logs and driver documentation; compare with another Appium client if the problem persists.
Locator finds no element	The element is not in the current screen source, the screen is in the wrong state, the attribute is different, or the content has not loaded.	Confirm the screen and source are current, inspect actual attributes, and wait for the app’s state transition before searching.
Locator finds several elements	The chosen attribute is shared by multiple nodes.	Use a more specific stable attribute or scope the search to an appropriate parent. Verify uniqueness in the test context.
A command is absent or fails in the Commands tab	The active driver or plugin does not provide it, or WebdriverIO does not support issuing it through this tab.	Check the Commands documentation, active driver and plugins, and WebdriverIO command support. Try an appropriate Appium client if the operation is supported elsewhere.
A platform control is missing	The control is driver, operating system, device, or version specific.	Check the current session header documentation and confirm the active session’s driver and version meet the control’s stated requirements.

To separate Inspector issues from server or driver issues, reproduce the behavior through another Appium client. The Appium project recommends reporting an issue in the main Appium repository if it also occurs with another client; if it only occurs in Inspector, report it in the Inspector repository.

7. Performance, reliability, and operating cost

Inspector is an interactive diagnostic tool, so session startup and source retrieval depend on the Appium server, driver, device or simulator, app startup, and network path. A large or complex screen can take longer to inspect than a small one. When source retrieval is slow, first check whether the app is still rendering, whether the device is responsive, and whether the server log shows a slow driver command.

For repeatable locator work, keep the app in a known state, inspect only the relevant screen, and verify candidate locators in the same driver and platform configuration used by the tests. A locator that worked in one session is not proof it will work across another OS version or app state. Keep driver, Inspector, and device configuration documented so failures can be reproduced.

The research sources describe Inspector distributions and functions but do not establish a price for the Inspector application or a performance benchmark. Cost for a particular workflow can depend on the infrastructure you use, including local hardware or a hosted device provider. Check current provider terms directly if you use hosted devices.

Or skip the browser setup

Appium Inspector is for inspecting native and hybrid mobile apps through Appium. If your task is to capture a website rather than inspect a mobile app, ScreenshotNeo offers a website screenshot API and MCP server. A single GET request can return a PNG, JPEG, WebP, or PDF. See the ScreenshotNeo API documentation for parameters and response details.

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webp

import requests

r = requests.get(
    "https://api.screenshotneo.com/v1/shot",
    params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"},
    timeout=90,
)
open("shot.webp", "wb").write(r.content)

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);

Cookie and consent banners, newsletter popups, and chat widgets are removed before the shot; each cleanup step can be turned off.
Bot checks and CAPTCHAs, blank pages, timeouts, failed loads, and cache hits are not billed. Response headers identify the page verdict and billing status.
An MCP server provides take_screenshot, get_page_info, and capture_pdf tools for AI agents, including Claude, Cursor, and other MCP clients.
The free plan includes 1,000 screenshots a month with no card. Paid plans start at $5 for 3,000 screenshots; every feature is on every plan.

Create a free ScreenshotNeo account to get 1,000 screenshots per month with no card.

Frequently asked questions

Is Appium Inspector an Appium server?

No. In the standalone workflow it is a client that connects to a separately installed and running Appium server.

Can I inspect an app without creating a session?

The screenshot and hierarchy inspection workflow depends on an active Appium session connected to the target app and device.

Does Inspector generate production-ready test code for every language?

The supplied documentation establishes inspection, element search, interaction, and command features, not universal test-code generation for every language. Use Inspector to investigate candidate locators and verify them in your chosen Appium client and test framework.

Why does the same locator behave differently on another platform?

The app’s UI representation, available attributes, and driver behavior can differ by platform. Inspect and validate locators in each target platform’s own session.

Which Inspector version should I install?

Use the current official releases and check current operating system and driver requirements at installation time. Version and OS support can change.