Next-Gen App & Browser Testing Cloud
Trusted by 2 Mn+ QAs & Devs to accelerate their release cycles

Learn How to Install Appium to make testing mobile apps easier. Utilize Appium for both Android and iOS platforms to streamline your testing process

Jainish Patel
January 13, 2026
More than 5.5 million mobile applications are listed on Google Play and iOS Apple App Store. Many applications publish on Android and iOS, which are used on different screen sizes and OS versions. It becomes very crucial to test the application thoroughly. Appium is one of the most popular testing frameworks.
Appium is an automated testing framework for native, hybrid, and mobile web applications. It works with various mobile operating systems, including Android, iOS, and Windows. Appium supports multiple programming languages and frameworks for mobile automation testing, including Java, JavaScript, Python, PHP, C#, etc.
Appium is an open-source test automation tool used to test mobile applications on Android and iOS. Installing Appium is easy once Node.js and platform tools are properly set up. You can install it using npm or Appium Desktop, and then verify your setup before starting automation tests.
How do I install Appium on Windows, macOS, or Linux?
To install Appium, first install Node.js (LTS version) from nodejs.org. Then, open your Command Prompt (Windows) or Terminal (macOS/Linux) and run:
npm install -g appium to install Appium globally.appium to start the server.What are the prerequisites before installing Appium?
Before using Appium, make sure you have the following setup to ensure smooth installation and device detection.
node -v and npm -v.JAVA_HOME correctly.ANDROID_HOME and update PATH properly.How do I check if Appium is installed correctly?
Run the following commands to confirm your installation and check for setup completeness.
appium -v to confirm installation.npm install -g appium-doctor and appium-doctor --android.What are common issues during Appium installation?
Here are common setup issues and their quick fixes to help you troubleshoot effectively.
appium --port 4724 to use a different port.JAVA_HOME and ANDROID_HOME paths.Run as Administrator or sudo while installing.appium driver install uiautomator2.In this article, we will discuss various aspects like Appium Architecture, How to install Appium on Windows, macOS, and Linux Operating Systems. Apart from this, we will also see some common issues and it’s troubleshooting with some best practices.
Appium is an automation testing framework used for mobile app testing. It excels in UI automation, allowing developers and testers to create code that simulates real-world behavior by iteratively running through user scenarios within the application’s actual user interface (UI). This approach closely mimics real user interactions, maximizing performance, scalability, and consistency while leveraging the benefits of automation.
Appium was originally developed to automate iOS and Android mobile applications. It has now developed into a fully functional platform offering a WebDriver-based automation framework for various mobile and desktop platforms to improve mobile performance testing. Appium is an open-source project with more than 16.7K Star and 5.9K Fork on GitHub at the time of mention and maintained by a community of open-source developers and testers that enables them to request new features or functionality or build it themselves.
Due to its advantages and benefits over other automation frameworks like Cypress, Google Firebase Test Lab, Katalon Platform, and Cucumber, Appium is a popular choice for testing mobile apps. In this section, we will look at some of the significant advantages.
Note: Automate Android apps on the Appium cloud of 3000+ real devices. Try TestMu AI Today!
Before proceeding further with the installation process, we will understand how Appium 2 works using its architecture. It will help to get an overview of the working principles.

The Appium Architecture consists of 3 components:
Now that we have enough knowledge of Appium. Let’s start with the installation process for Appium.
You must confirm that your machine satisfies the following system requirements before installing Appium 2:
Understanding your operating system’s requirements is crucial not only for Appium but also for various other technical aspects. For insights into commonly asked operating system interview questions, check out our guide for essential tips and concepts.
The upcoming section will cover all the requirements for the correct functionality of Appium version 2.
Check out these steps for Appium installation:
npm install -g appium.appium in the Command Prompt to ensure Appium is working correctly.Now let us check out these steps in detail.
Note: As Appium launched version 2 recently, there is a high chance that you will have to learn about Migrating From Appium 1.x To Appium 2.x . Consider Checking It Out!
Appium framework depends on the npm package manager for its installation, so we have first to install node.js. After that, we will download some other requirements like Java Development Kit (JDK)/OpenJDK, Android SDK, and Xcode. We will see each installation process in detail.
Since Node.js is the foundation of Appium, you must install it on your system. If Node.js is not installed on your system, you can install it by following these steps:

To check the Node.js version:
node -v
To check the npm version:
npm -v
Console Output:

If both instructions display the version numbers without any errors, Node.js and npm have been correctly installed.
Note: There are two major providers for Java Development Kit; one is from Oracle JDK, and the other is OpenJDK. You can install whichever satisfies your requirement.
Appium 2 requires JDK 8 or later to be installed. So, If JDK is not installed on your system, then you can install it by following the steps:

Windows:
macOS and Linux:
If you’re using bash, all you have to use the following command:
echo export "JAVA_HOME=\$(/usr/libexec/java_home)" >> ~/.bash_profile
If you’re using zsh (which probably means you’re running macOS Catalina or newer), then it should instead be:
echo export "JAVA_HOME=\$(/usr/libexec/java_home)" >> ~/.zshrc
java -version

The Java Platform, Standard Edition (Java SE) is implemented in OpenJDK (Open Java Development Kit), a free and open-source software program. It acts as a free, open-source replacement for Oracle’s Java Development Kit (JDK). The OpenJDK community, which consists of people, businesses, and organizations interested in advancing Java technology, is primarily responsible for developing the project.
Appium 2 requires JDK 8 or later to be installed. So, If JDK is not installed on your system, you can install it by following the steps:

Windows:
macOS and Linux:
tar -xf openjdk-20.0.2_macos-aarch64_bin.tar.gz -C $HOME/OpenJDK
Note: YOU HAVE TO HAVE CHANGE THE FILE NAME IF THE NAME IS NOT SAME FOR EVERY COMMAND.
Console Output:

cd $HOME
cat > .zshrc
export JAVA_HOME=$HOME/OpenJDK/jdk-20.0.2.jdk/Contents/Home
export PATH=$JAVA_HOME/bin:$PATH

cat .zshrc
Console Output:

Console Output:

Install the Android SDK and set the required environment variables if you want to automate Android apps. To install the Android SDK (Software Development Kit), follow these steps:
Windows:
macOS and Linux:
export ANDROID_HOME="/path/to/android-sdk"
Note: replace “/path/to/android-sdk” with the actual JDK installation directory.
Using Android Studio, the Android SDK has been installed successfully. The tools, libraries, and system images required for creating and testing Android apps using Appium are provided by the Android SDK.
If you prefer to test your application on a virtual device, then you need to set up an Android Emulator. Learn what an Android emulator is, its advantages, and how to set one up by watching the video.
You must install Xcode on macOS to automate iOS apps. Xcode is a product of Apple, so it will only run and be installed on Apple devices like MacBooks and iMacs.
To install Xcode on macOS, follow these steps:
Note: Installing Xcode also requires installing command-line tools, such as the iOS Simulator, which is used to run simulations of iOS apps when running Appium tests.
Your macOS system’s Xcode program has been installed successfully. Xcode provides the essential emulators, compilers, and tools for creating and testing iOS apps with Appium.
It’s crucial to follow the installation guidelines for your operating system and the official Appium documentation for any upgrades or additional specifications. The handbook offers comprehensive instructions for setting up Appium on several platforms.
Now that all the required software is installed. We are all set to install Appium and start automation testing.
To install Appium through NPM, run the following command prompt in the terminal:
npm install -g appium

Appium 2.0 deprecated the functionality of downloading Appium using the GUI version. So the only option for downloading is using the NPM package manager.
Apart from Appium, you also need some other tools like UiAutomator2, XCUITest, Appium client, Appium Plugins, and Appium Inspector to interact with your application.
User interface (UI) interactions and testing on Android devices are automated using the testing framework and driver known as UiAutomator2. It is a component of the Appium framework and was created specifically for automating native and hybrid Android apps.
You can use the ‘official’ driver name for the UiAutomator2 driver to quickly install it using the Appium Extension CLI because the core Appium team maintains it.
appium driver install uiautomator2
It will look something like this:

Apple offers the XCUITest framework for automating the UI (user interface) testing of iOS applications. It is a component of Xcode, Apple’s integrated development environment (IDE), and was created exclusively for testing iOS apps. XCUITest enables testers to interact with the UI parts of the app, carry out tasks like tapping, scrolling, and text input, and verify the UI’s intended behavior.
To install XCUITest run the following command:
appium driver install xcuitest
It will look something like this:

If you don’t want any hassle in setting up Environment Variables and running multiple commands you can also use appium-installer.
npm install -g appium-installer
It will look something like this:

You can run the installer using the following command:
appium-installer
After running the following command it will provide various set up options:

You can refer to the following video if you are stuck in between the installation process.
To communicate with the Appium server and automate mobile app testing in multiple programming languages, Appium provides several client libraries. The following list of well-liked Appium client libraries:
To install the Appium client for Java:
Maven: mvnrepository
Add the following to pom.xml file:
<dependency>
<groupId>io.appium</groupId>
<artifactId>java-client</artifactId>
<version>8.5.1</version>
<scope>test</scope>
</dependency>
Gradle:
Add the following to build.gradle file:
dependencies {
testImplementation 'io.appium:java-client:8.5.1'
}
To install the Appium client for Python you can run the following command:
pip install Appium-Python-Client
Console Output:

To install the Appium client for JavaScript, you can run the following command:
npm i --save-dev webdriverio
Console Output:

To install the Appium client for Ruby you can run the following command:
gem install appium_lib
# or
gem install appium_lib_core
Console Output:

To install the Appium client for C#, you can run the following command:
dotnet add package Appium.WebDriver --version 4.4.5
Console Output:

Appium offers several plugins that increase the functionality and testing potential of mobile app automation. These plugins provide extra functionality and support for particular use scenarios.
Some of the useful plugins and commands for installing it are shown below:
appium plugin install images

appium plugin install --source=npm appium-device-farm
Console Output:

appium plugin install --source=npm appium-dashboard

appium plugin list --installed

appium plugin update device-farm

appium plugin uninstall appium-device-farm
Console Output:

appium plugin install --source=local /Users/me/sources/images
A complete list of third-party and official plugins can be found in the most recent Appium 2.0 documentation.
With the help of the Appium Inspector tool, you may examine and interact with a mobile application’s user interface (UI) components. It offers a graphical user interface (GUI) so that you may inspect individual pieces, view the app’s UI hierarchy, and get an ID, Accessibility ID, ClassName, or XPath as locators in Appium for automation. You can use the Appium Inspector online version using inspector.appiumpro.com. Refer to our detailed blog on Appium Inspector.
Note: Boost your efficiency by ultimate guide of Appium Commands Cheat Sheet for Developers.
Follow these steps to see if Appium has been successfully installed and to look for any error messages. There are two ways to check whether the Appium installation is successful.
It is a tool to verify if any requirements, dependencies, or installs are missing or not. To use Appium Doctor one needs to install it by running the following command:
npm install appium-doctor -g
Console Output:

Once the Appium Doctor is installed you can run this command which provides various types of checks to be verified:
appium-doctor -h
The above command will output the following list:

You can use any command like below:
For Android setup check:
appium-doctor --android
Console Output:

Checkmark confirms that all the requirements for Android are completed.
For iOS setup check:
appium-doctor --ios
Console Output:

Checkmark confirms that all the requirements for iOS are completed.
appium -v or appium --version

appium
Console Output:

!["Appium REST http interface listener started on [http://0.0.0.0:4723]" "Appium REST http interface listener started on [http://0.0.0.0:4723]"](https://assets.testmuai.com/resources/uploads/2023/07/image30.png)
Note: If the port is already occupied, then you can start the Appuim on a new port by the following command:
appium --port 4724

You can use desired port number; it is not mandatory to use port 4724.
By following these steps, you can verify if Appium is installed correctly and check for any error messages during the launch of the Appium server. This ensures that Appium is set up properly and ready for mobile app testing.
The installation of Appium may cause you to run into a few frequent problems. Here are some of them, along with some advice for fixing them:

One of the most common issues you might face is resource management. Most developers and testers who use Android Studio or Xcode require high-end resources for running and testing their applications.
One of the solutions is to use real devices for testing. However, it is not practically possible to test developed applications on various devices. To solve this issue, Appium provides support to different cloud testing platforms. One is TestMu AI, an AI-powered test orchestration and execution platform that provides multiple testing types for your native, and mobile web applications.
Note: Automate Android apps on the Appium cloud of 3000+ real devices. Try TestMu AI Today!
Check out the following resources to learn how to run Appium tests on TestMu AI Cloud Grid:
Here are some recommendations for setting up Appium to enhance the testing of mobile applications:
For instance, you might need to lengthen the timeouts for your tests if your application involves numerous complex interactions. The Appium server will have more time to wait for the application to respond. Your tests could hang, though, if you overextend the timeouts.
Similarly, you might need to shorten the timeouts for your tests if your network is slow. By doing this, you can stop your tests from hanging as they wait for the device or app to respond.
To delve deeper into the realm of Appium, explore our dedicated hub focusing on Appium Interview Questions.
Appium is a popular option for testing mobile apps due to its cross-platform capabilities, support for numerous programming languages. The architecture of Appium provides seamless interaction with native, hybrid, and mobile web apps on both the Android and iOS platforms by utilizing client-server communication and automation drivers.
The prerequisites for installing Appium, such as Node.js, JDK, Android SDK, and Xcode, ensure that Appium will operate effectively in a stable and compatible environment. We show step-by-step installation instructions for each software to simplify the setup procedure.
After that, we proceed further by installing Appium using the npm package manager. With that, we also install other required dependencies like Appium clients, plugins, and the Appium Inspector, which further emphasizes how versatile and extensible Appium is as a testing platform.
We also saw how to verify that Appium is successfully installed. Along with troubleshooting advice for Common installation issues. It focuses on the significance of defining required capabilities, selecting the best testing environment (Real Devices as opposed to emulators/simulators), and successfully managing test data and environment.
Developers and testers may maximize their mobile app testing efforts, increase efficiency, and guarantee thorough test coverage by following the best practices for Appium settings.
In conclusion, this extensive article explains how to install, configure, and use Appium for successful mobile app testing.
AI in Mobile Testing isn’t just the future. It’s happening now. Discover how to get started.
Did you find this page helpful?
More Related Hubs
TestMu AI forEnterprise
Get access to solutions built on Enterprise
grade security, privacy, & compliance