Making sure a website looks and functions the same on every device is now very important in software development. As smartphones and tablets become more common, mobile testing has become essential. Selenium is still a favourite among many automation tools used in testing. While Selenium was first intended for use in desktop web browsers, it can now be applied to mobile devices as well, mainly thanks to its integration with Appium.
This blog explores Selenium mobile testing, the tools and technologies needed, ways to automate tests for mobile web and apps, and best practices for success.
Table of Contents
Introduction to Selenium Mobile Testing
Selenium is an open-source tool designed mainly to test web applications. The interest of the community has resulted in the addition of a framework that lets users test their software on mobile devices. Selenium cannot check native mobile apps by itself, yet it is still very useful when paired with tools such as Appium.
Mobile testing using Selenium generally falls into two categories:
Mobile Testing: Checking website functions on mobile phone web browsers.
Mobile App Testing: Testing Native and Hybrid Applications: One aspect of mobile testing.
Both of these development methods are best done with special care because there are so many types of mobile devices, screens, operating systems and browsers to consider.
Why Mobile Testing Matters
Currently, in 2025, mobile phones and tablets make up more than 60% of world wide web traffic. People mainly use mobile apps for activities such as banking, seeking medical care or buying items online. Both desktop and mobile users want their apps to run well, have simple menus, pass a mobile friendly test, and be free from bugs. One mistake could make people delete the app or doubt your brand.
Mobile testing helps in:
Ensuring responsive design compatibility
Validating UI/UX elements across devices
Confirming functional and non-functional requirements
Improving app stability and performance
Enhancing user satisfaction and retention
Understanding Selenium’s Capabilities
Selenium consists of several components:
Selenium WebDriver: Interacts directly with browsers.
Selenium IDE: A record-and-playback tool.
Selenium Grid: This lets you run tests on different environments all at once.
WebDriver in Selenium supports four main programming languages (Java, Python, C# and JavaScript), and you can use third-party tools to write tests for mobile devices.
What is Appium?
Leveraging Appium, you can create automated testing for native, hybrid and web apps on iOS and Android handsets. The testing is supported by the WebDriver protocol the same way Selenium does, making it suitable for Selenium-based tests.
Key Features of Appium:
Supports all major programming languages
Can test apps without modifying them
It uses the same API for iOS and Android.
Supports parallel test execution
Allows access to mobile device functions like GPS, camera, and gestures
Selenium vs Appium: How They Work Together
Though great at testing web applications, Selenium does not directly access mobile browser environments. Appium is used here to link these systems. Appium receives Selenium WebDriver commands and then sends them as UIAutomation commands for iOS or UIAutomator/Espresso commands for Android.
Together, Selenium and Appium give us a powerful tool for testing web applications.
Mobile Web Apps using Selenium WebDriver
Mobile Native & Hybrid Apps using Appium’s drivers
It allows test engineers to write a unified test suite for both web and mobile environments.
Setting Up Selenium for Mobile Testing
Let’s have a look:
Prerequisites:
Install Java Development Kit (JDK)
Install Android Studio and set up an emulator or connect a real device.
Install Node.js and Appium server
Install Selenium WebDriver
Choose a test framework (e.g., TestNG, JUnit, or PyTest)
Sample Configuration for Android (Java):
DesiredCapabilities capabilities = new DesiredCapabilities();
capabilities.setCapability(“platformName”, “Android”);
capabilities.setCapability(“platformVersion”, “12”);
capabilities.setCapability(“deviceName”, “Android Emulator”);
capabilities.setCapability(“browserName”, “Chrome”);
WebDriver driver = new RemoteWebDriver(new URL(“http://localhost:4723/wd/hub“), capabilities);
It sets up a remote WebDriver session using Appium for mobile web testing.
Automating Mobile Web Testing with Selenium
Mobile web testing checks if websites are working as expected when opened on Android browsers using Google Chrome or iOS browsers using Safari. When using mobile devices, extra factors such as a smaller display, different mobile controls, various devices and weak internet connections must be verified to avoid problems for users.
Key Areas to Test
When automating mobile web testing, focus on these critical areas:
Responsive Design
Ensure that your design appears well on any size screen, whether it is held in portrait or landscape mode. View all the images, menus, paragraphs and buttons on different devices (tablets, desktops, smartphones) and confirm that everything is in place and can be used correctly.
Touch Functionality
Interactive items (buttons, sliders, menus) should be usable with touches from a finger. In addition, look at test pinch-to-zoom, long-press and swipe actions if they play a role in your web design.
Page Rendering Speed
Users who access the Internet with their mobile devices frequently experience bandwidth restraints. A slow website can reduce how engaged users are and also affect your search engine rankings. Use browser logs or Chrome DevTools Protocol to check load speed and find the resources that are stopping the site from working correctly.
Cross-Browser Compatibility
Your site should function consistently across mobile browsers. Chrome, Safari, Firefox, and Samsung Internet can all render web pages differently on mobile, so your test suite should ideally include each.
Form Input and Validation
Forms should be easy to interact with on small screens. Validate input fields for formatting errors, check soft keyboard behavior, and ensure that form submission works under various conditions.
Viewport and Meta Tags
Ensure thetag is set correctly so that browsers render the page at the correct scale and size.
Media Queries and CSS Breakpoints
Test that your media queries trigger the correct styles at different resolutions and that visual elements do not overlap or disappear unexpectedly.
Emulators vs Real Devices
You can simulate different devices using browser dev tools or mobile emulators. Although emulators help during the starting phase and in automation, you still need real devices to check if the software complies with the real devices and network settings. With tools like LambdaTest, it is possible to perform testing on many different real devices from the cloud.
Setting Up a Test: Example Using Python + Selenium + Appium
Below is a sample script to automate a mobile web test using Chrome on an Android emulator:
from appium import webdriver
Define desired capabilities for the mobile browser
desired_caps = {
“platformName”: “Android”, # Target mobile platform
“deviceName”: “Android Emulator”, # Emulator or real device name
“browserName”: “Chrome” # Mobile browser to test
}
Start a remote WebDriver session with Appium server
driver = webdriver.Remote(“http://localhost:4723/wd/hub“, desired_caps)
Open the test website
driver.get(“https://example.com“)
Validate that the page title is as expected
assert “Example Domain” in driver.title
End the WebDriver session
driver.quit()
What This Script Does
Creates a desired capabilities dictionary that defines the platform and browser.
Connects to the Appium server running on your local machine (http://localhost:4723/wd/hub).
Launches the mobile browser and navigates to a specific URL.
Validates the page title to confirm successful loading.
Closes the driver, freeing up resources.
Tips for Enhancing Mobile Web Automation
Use explicit waits (like WebDriverWait) instead of arbitrary sleep calls to improve test reliability.
Utilize browser developer tools to collect logs and performance metrics.
Integrate your test suite with a CI/CD pipeline for regular execution across builds.
Add screenshot capture and HTML dump functionality to help debug test failures.
Example of Explicit Wait
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
wait = WebDriverWait(driver, 10)
element = wait.until(EC.presence_of_element_located((By.TAG_NAME, “h1”)))
assert element.text == “Example Domain”
This wait ensures the
element is present before continuing the test, reducing flakiness in slower environments.
Automating Mobile App Testing with Appium
Native apps require interaction beyond the web layer. Appium provides support for gestures, app lifecycle, sensors, and more.
Capabilities for Native App Testing:
app: Path to the .apk or .ipa file
automationName: UIAutomator2 (Android), XCUITest (iOS)
deviceName, platformVersion, platformName
Example for Android App Testing:
capabilities.setCapability(“app”, “/path/to/app.apk”);
capabilities.setCapability(“automationName”, “UiAutomator2”);
AndroidDriver driver = new AndroidDriver(new URL(“http://localhost:4723/wd/hub“), capabilities);
It is possible to interact with parts of an app by using locators like id, className, accessibilityId or XPath.
Key Challenges in Mobile Automation
Despite its benefits, mobile testing poses several challenges:
Device Fragmentation: Testing on various screen sizes and OS versions
Network Variability: Apps may behave differently on 3G, 4G, or WiFi
Hardware Access: GPS, camera, and fingerprint sensors need special handling.
Test Stability: Flaky tests due to synchronization or animation delays
Maintenance: High cost to maintain and update test suites regularly
Overcoming these requires proper planning, real-device testing, and continuous integration.
Best Practices for Selenium Mobile Testing
Let’s have a look at some of the best practices for Selenium mobile testing::
Use Real Devices: Emulators are useful but can’t replicate all real-world conditions.
Leverage Cloud Platforms: Using a cloud-based platform such as LambdaTest helps create tests that run immediately on many operating systems, browsers and devices across the world. It’s also a great way to run a mobile friendly test to ensure your website or app looks and works well on different screen sizes and mobile environments. With help from LambdaTest, you can use automation testing frameworks and link them to continuous integration and delivery (CI/CD) pipelines.
Implement Page Object Model: Improves maintainability and scalability of test code.
Use Waits Smartly: Prefer explicit waits over implicit waits to enhance reliability.
Test in Parallel: Use Selenium Grid or cloud services to run tests simultaneously.
Keep Tests Atomic: Each test should validate a single functionality.
Use CI/CD Pipelines: A good approach is to use Jenkins, GitLab CI or GitHub Actions to set up automation in your CI/CD Pipeline.
Enable Logging: Capture logs and screenshots for better debugging.
Handle Permissions Gracefully: Automate permission prompts where possible.
Version Control Your Test Suite: Keep track of changes for easy rollback and collaboration.
Real-World Use Cases
Let’s have a look:
E-Commerce Apps:
Companies like Amazon use Selenium and Appium for cross-platform regression testing, ensuring UI consistency and quick feature validation.
Banking Applications:
Apps like PayPal and mobile banking services automate security workflows, login sessions, and transaction flows using Selenium-based mobile testing.
Ride-Sharing Services:
Uber and Lyft utilize Appium to automate map interactions, booking flows, and real-time UI updates on different devices.
Final Thoughts
When used with Appium, Selenium mobile testing makes it easy to automate tests for mobile web as well as native applications. Nowadays, as people use mobile solutions more often than desktops, giving users a perfect experience on all devices is not something optional; it is always necessary.
In this blog, we provided information and best practices for all fundamental aspects, from setting up your test environment to writing automation scripts and including them in CI/CD pipelines. As challenges stemming from device and network diversity and unreliable testing continue, using the correct combination of tools and cloud platforms can make the process much easier.
If you are a beginner in mobile testing or already have test cases, combining Selenium and Appium gives teams a chance to combine web and app automation, increase their test range and improve how users interact with the system. Since automation and AI are being used more in software development, keeping up and learning new skills will help maintain the quality of software for mobile devices.