Understanding Appium Drivers And Desired Capabilities

By Dhwani Madan | Software & Tools

In the present day, ensuring seamless functionality of mobile applications across various platforms is more crucial than ever. Real device testing is the gold standard in this realm, providing the most accurate insights into an app’s performance, user experience, and overall reliability. While numerous tools are available for this purpose, Appium stands out as an open-source, cross-platform automation tool for native, hybrid, and mobile web applications. Central to Appium’s robustness and versatility are its drivers and “Desired Capabilities,” which are the backbone for automating tests and interacting with different mobile operating systems. 

This article aims to delve into the intricacies of Appium’s drivers and the concept of Desired Capabilities, elucidating their pivotal role in effective mobile application testing.

What Are Appium Drivers?

In the context of Appium, drivers are software components that allow you to interface with the mobile application and device. Each driver understands how to interact with the application under test on a specific platform (e.g., iOS, Android). By using these drivers, you can simulate user behaviors such as tapping buttons, scrolling, filling out forms, etc., and also verify the application’s state.

Most Common Appium Drivers

One of Appium’s key features is its extensibility through various driver plugins that allow it to interact with different platforms and technologies. Below are some of the most common Appium drivers

  • XCUITest Driver: This driver is used for automating iOS applications. It uses Apple’s XCUITest framework to interact with the iOS app.
  • UiAutomator2 Driver: For Android applications running on Android 5.0 and newer, UiAutomator2 is generally the recommended driver.
  • Espresso Driver: Another driver for Android, Espresso provides a more concise API and faster execution but might require modification to the application under test.
  • Selendroid Driver: For older Android versions (below 5.0), Selendroid can be used. It’s not as up-to-date or efficient as UiAutomator2, but it’s an option for legacy applications.
  • Windows Driver: Appium automation also supports Windows applications through WinAppDriver.
  • Mac Driver: For macOS desktop applications, you can use the Mac driver to execute your tests.

Benefits Of Using Different Appium Drivers

Appium offers various benefits when it comes to using its drivers for automating the testing process. Here are some key advantages of using Appium drivers.

  • Cross-Platform Compatibility: Appium drivers enable cross-platform automation, allowing you to write test scripts once and run them on multiple platforms like Android and iOS without major modifications. This reduces development effort and ensures consistent testing across different devices.
  • Native And Web Application Testing: Appium drivers support native and web application testing. You can automate interactions with native app elements and web views within hybrid applications, providing a comprehensive testing solution for various application types.
  • Wide Range Of Locator Strategies: Appium drivers offer multiple locator strategies to identify UI elements, such as ID, name, XPath, CSS selectors, etc. This gives you flexibility in locating elements and adapting to changes in the UI structure.
  • App Installation And Management: Appium drivers provide built-in capabilities for app installation and management. You can install, uninstall, or update apps on devices or emulators/simulators as part of your test scripts, streamlining the testing process.
  • Support For Gestures And Interactions: Appium drivers support various gestures and interactions, including swiping, tapping, scrolling, and pinching. This enables you to test user interactions thoroughly and replicate real-world usage scenarios.

What Are Appium Desired Capabilities?

Desired capabilities are keys and values sent to the Appium server to tell it what kind of automation session we’re interested in starting up. These keys and values communicate essential information to the Appium server. For example, desired capabilities might specify the type of mobile platform you want to run tests on (Android, iOS), the name of the device, the path to the app you’re testing, and many other parameters.

Most Common Desired Capabilities In Appium

Here is the list of some of the most commonly used desired capabilities when testing with Appium:

General Capabilities

1. platform name: The name of the mobile OS to use (`Android` or `iOS`).

2. platformVersion: The version of the mobile OS.

3. deviceName The name of the emulator or actual device.

4.automationName: Automation engine to use (`Appium,` `UiAutomator2` for Android, `XCUITest` for iOS).

5. browserName: For mobile web automation, this specifies which browser to use (`Safari` for iOS, `Chrome` for Android).

6. noReset: Resetting the app state before the test run.

7. fullReset: Whether to perform a complete clean and reset before running tests (incompatible with `noReset`).

8. app: The absolute path of the application under test (typically a `.apk` file for Android or `.ipa` for iOS).

9. appPackage and appActivity: For Android, the package and initial activity of the app.

10. udid: Unique device identifier of the connected physical device.

Android-Specific Capabilities

1. systemPort: Port for the UiAutomator2 server to use.

2. autoGrantPermissions: Automatically grant requested permissions during installation.

iOS-Specific Capabilities

1. xcodeOrgId and xcodeSigningId: Code Signing details for iOS.

2. bundleId: Bundle ID of the app under test.

3. useNewWDA: Whether to uninstall and reinstall WebDriverAgent before a new session (only applies to real devices).

4. showXcodeLog: Whether to display the Xcode log during test execution.

Best Practices for Using Appium Desired Capabilities Effectively

Here are some best practices for using Appium Desired Capabilities effectively.

Understand Core Capabilities

  • Core capabilities are the foundation for how Appium interacts with the device and application you’re testing. For example, specifying the platformName tells Appium whether you are testing on Android, iOS, or another platform. The platform Version allows you to define which version of the mobile operating system you are targeting, which is essential for compatibility testing. 
  • The deviceName is another core capability particularly useful when running tests on multiple devices simultaneously. By setting the deviceName, you instruct Appium to run tests on a specific device, whether an emulator or an actual device. This is especially important in large testing environments where multiple devices with different specifications are available.
  • Incorrectly setting this capability would mean that Appium wouldn’t know which application to install or interact with, making the test fail immediately. Therefore, gaining a good grasp of these capabilities is key to achieving accurate and effective test results.

Use Version-Specific Capabilities

  • Some capabilities are version-specific. Ensure you’re using the right set of capabilities for the version of the mobile OS you are automating. For example, some capabilities introduced in later versions of Android or iOS might not be backward compatible with older versions. Using such capabilities without consideration for the version you’re testing on could lead to test failures or unpredictable behavior. 
  • Additionally, version-specific capabilities allow you to leverage features unique to a particular OS version. It is beneficial for compatibility testing, ensuring your application performs well across various versions.
  • Another dimension to consider is that Appium itself evolves. As new versions of Appium are released, new capabilities are often introduced, and existing ones may change their behavior or become deprecated. Therefore, keeping your mobile OS and Appium versions in sync and well-documented is crucial to knowing which capabilities to use.

Always Use Valid Values

  • The importance of using valid values for Appium’s desired capabilities cannot be overstated. When you input invalid or incorrect values for any capability, you risk introducing many problems into your testing process. At best, your test case may fail to initialize, providing you with an error message. At worst, you could encounter undefined behavior that is difficult to troubleshoot, leading to misleading test results and consuming valuable time and resources.
  • For instance, providing an incorrect path in the `app` capability would prevent the Appium server from locating and installing the app, leading to an immediate test failure. Similarly, specifying an incorrect platformVersion that doesn’t exist or isn’t compatible with your testing setup might lead to unpredictable results or errors that are challenging to diagnose. Invalid values in capabilities like `deviceOrientation` could lead to scenarios where the device stays unexpected, affecting subsequent test cases and overall test reliability.
  • To mitigate these issues, it’s crucial to validate your capability values meticulously. This may involve checking that file paths are correct, verifying that device names and OS versions are accurate, and confirming that timeout values are appropriate for the test scenarios. Automation frameworks may provide ways to validate these values programmatically, but it’s also good practice to double-check them manually or through code reviews.

Separate Common And Unique Capabilities

  • Organizing capabilities into common and unique sets is a powerful strategy for managing tests across multiple devices or platform versions efficiently. This approach not only improves the maintainability of your test code but also enhances its readability and flexibility.
  • Common capabilities are those that apply to all test scenarios regardless of the device or platform being used. For example, you might have capabilities related to the app’s location, timeouts, or general preferences that are consistent across all test cases. By isolating these common capabilities, you can define them once in your test setup and reuse them across multiple test scenarios. This promotes code reusability and makes it easier to manage updates or changes; a change to a common capability needs to be made in just one place, reducing the chances of errors or inconsistencies.
  • On the other hand, unique capabilities pertain to specific test cases and may depend on the device type, platform version, or other specialized requirements. For instance, the deviceName, platformVersion, or udid could be different when you are running tests concurrently on multiple devices or versions. These unique capabilities can be extended or overridden programmatically for each test case based on your needs.
  • Separating common and unique capabilities also allows for greater scalability in your testing environment. As your test matrix grows to include more devices or platform versions, you can easily extend your test setup to accommodate them. You simply add or override unique capabilities without modifying the standard capabilities, which remain consistent and reusable.


Appium drivers and desired capabilities are vital for mobile automation testing, enabling seamless interaction between your test code and the mobile application under test. Understanding these components is crucial for writing robust, effective test scripts. However, to take your mobile testing to the next level, consider integrating your Appium tests with LambdaTest. LambdaTest is an AI-powered test orchestration and execution platform that has 3000+ browsers and OS combinations, along with great support on emulators and simulators for real device testing. LambdaTest accesses a scalable, cloud-based test infrastructure that lets you run your Appium tests across various mobile devices and versions, saving time and resources. 

Moreover, LambdaTest’s insightful analytics and collaborative features make sharing results and troubleshooting issues easier, accelerating your go-to-market strategy. So, unlock the full potential of your mobile application by leveraging the synergy between Appium’s capabilities and LambdaTest’s comprehensive testing platform today.