> Mobilewright vs WebdriverIO for Mobile App Testing
> Canonical: https://mobilewright.dev/compare/mobilewright-vs-webdriverio/

Comparison · vs WebdriverIO

# Mobilewright vs WebdriverIO

Both are TypeScript. WebdriverIO reaches a phone through an Appium server; Mobilewright talks to the device directly.

Last updated: November 15, 2026

## Mobilewright vs WebdriverIO, feature by feature

| Dimension | Mobilewright | WebdriverIO |
| --- | --- | --- |
| How it reaches the device | Directly. No server to run | Through an Appium server and a driver per platform (@wdio/appium-service starts the server for you) |
| Language | TypeScript / JavaScript | TypeScript / JavaScript |
| Setup | npm init mobilewright@latest (Needs Node.js, plus Xcode or the Android SDK) | WebdriverIO, Appium, the XCUITest and UiAutomator2 drivers, then capabilities (Needs the same Xcode or Android SDK. Version 10 requires Appium 3) |
| Locators | getByRole, getByLabel, getByText, getByTestId, the same on iOS and Android | Accessibility id (~) on both platforms (By text or type: iOS predicate strings, Android UiSelector or XPath, one per platform) |
| Auto-waiting | Before each action: exists, visible, enabled, stable | Element commands wait for the element to exist (Retries once if the driver reports the element as not interactable) |
| Assertions | expect() retries until it passes or times out | expect-webdriverio matchers retry the same way |
| Gestures | tap, doubleTap, longPress, swipe, custom gestures | tap, swipe, longPress, pinch, zoom, dragAndDrop (Added in version 9) |
| Real devices | iOS and Android | iOS and Android, through Appium |
| Beyond native apps | Web views inside the app, with a Playwright-compatible Page (No browsers, no desktop apps) | Browsers, mobile web, hybrid apps, Electron, Tauri, macOS, TV apps (The widest coverage of any tool on this page) |
| Test runner | Built on Playwright's runner: fixtures, projects, retries, workers, sharding | Mocha, Jasmine, Cucumber or Vitest; parallel spec files, sharding, retries |
| Reporting | HTML report, screenshots, video, JUnit and JSON built in | Reporter packages: spec, JUnit, Allure, HTML, video (Also a visual testing service that works on native apps) |
| Cloud devices | Mobile Next Cloud, BrowserStack, Sauce Labs, TestingBot, TestMu AI | Sauce Labs, BrowserStack, TestingBot, TestMu AI, Perfecto and more |
| AI agents | Mobile MCP and an agent CLI, from the same team (No server behind them) | Official @wdio/mcp server, covers native apps (Requires a running Appium server) |
| Maturity | New. 0.0.x releases, several a month | Version 10, an OpenJS Foundation project (About 3.4 million npm downloads a week) |
| License | Apache 2.0, open source | MIT, open source |

## The same test, side by side

WebdriverIO + Appium

```
// wdio.conf.ts
export const config: WebdriverIO.Config = {
  runner: 'local',
  port: 4723,
  specs: ['./test/specs/**/*.ts'],
  services: ['appium'],
  capabilities: [{
    platformName: 'iOS',
    'appium:automationName': 'XCUITest',
    'appium:deviceName': 'iPhone 17',
    'appium:platformVersion': '26.5',
    'appium:app': './build/MyApp.app',
  }],
  waitforTimeout: 10000,
  framework: 'mocha',
  reporters: ['spec'],
  mochaOpts: { ui: 'bdd', timeout: 60000 },
};

// test/specs/login.e2e.ts
import { $, expect } from '@wdio/globals';

describe('Login', () => {
  it('signs in with valid credentials', async () => {
    await $('~email').setValue('user@example.com');
    await $('~password').setValue('s3cret!');
    await $('~Sign in').tap();
    await expect($('~welcome-message')).toHaveText('Welcome');
  });
});
```

Mobilewright

```
// mobilewright.config.ts
import { defineConfig } from 'mobilewright';

export default defineConfig({
  platform: 'ios',
  bundleId: 'com.example.myapp',
  deviceName: /iPhone 17/,
  installApps: './build/MyApp.zip', // the zipped .app
});

// tests/login.spec.ts
import { test, expect } from '@mobilewright/test';

test('signs in with valid credentials', async ({ screen }) => {
  await screen.getByTestId('email').fill('user@example.com');
  await screen.getByTestId('password').fill('s3cret!');
  await screen.getByRole('button', { name: 'Sign in' }).tap();
  await expect(screen.getByTestId('welcome-message')).toHaveText('Welcome');
});
```

The tests are close. WebdriverIO's newer mobile commands, such as tap(), removed most of the gesture boilerplate it used to need, and both tools wait for the element and retry the assertion.

The difference is around the test. WebdriverIO needs an Appium server on port 4723, an installed driver and a capabilities block per platform. Mobilewright needs the platform and the app.

The ~ selector matches the accessibility identifier on iOS and the content description on Android, so the app has to set both to the same string. For anything else, such as finding a button by its role and caption, WebdriverIO uses a different selector on each platform.

### No Appium server underneath

WebdriverIO does not drive phones itself. Its docs put it plainly: it automates Android and iOS through Appium. So a mobile setup is WebdriverIO, plus an Appium server, plus the XCUITest and UiAutomator2 drivers, and the versions of all three have to agree. WebdriverIO 10 only runs with Appium 3.

Mobilewright ships its device layer inside the npm package. There is no server to start and no driver to install. npx mobilewright doctor checks Xcode, the Android SDK and your devices, and prints the fix for whatever is missing.

```
npm init mobilewright@latest
npx mobilewright doctor
npx mobilewright test
```

The whole setup, after Xcode or the Android SDK.

### One locator for both platforms

In WebdriverIO, an accessibility id works on both platforms. Past that, iOS uses predicate strings or class chains and Android uses UiSelector, so a cross-platform suite often carries two selectors per element, or falls back to XPath.

Mobilewright maps each platform's native types to roles. getByRole('button', { name: 'Sign in' }) finds a UIButton, a SwiftUI Button, a Compose Button and a React Native Pressable.

```
// WebdriverIO: by caption, per platform
$('-ios predicate string:label == "Sign in"')
$('android=new UiSelector().text("Sign in")')

// Mobilewright: both platforms
screen.getByRole('button', { name: 'Sign in' })
```

Role and name, not a selector dialect.

### Waiting before the action, not after the error

WebdriverIO does auto-wait. An element command waits for the element to exist, and if the driver then answers that the element is not interactable, WebdriverIO waits for it to be clickable and tries once more.

Mobilewright checks first. Before a tap it waits until the element exists, is visible, is enabled and has stopped moving, so a button that is still sliding in is not tapped at its old position.

```
await screen.getByRole('button', { name: 'Checkout' }).tap();
await expect(screen.getByText('Order placed')).toBeVisible();
```

No waitForDisplayed, no pause.

### Where WebdriverIO is the better tool

WebdriverIO tests browsers, mobile web, Electron and Tauri apps, macOS apps and TV apps with one runner and one set of reporters. If a mobile app is one of several things you test, that matters more than anything on this page.

It also has Cucumber support, a visual testing service that works on native apps, years of plugins, and the governance of the OpenJS Foundation. Mobilewright is new and does one thing: iOS and Android apps.

## Frequently asked questions

### Does WebdriverIO need Appium for mobile testing?

Yes. WebdriverIO automates native iOS and Android apps through an Appium server and the XCUITest and UiAutomator2 drivers. Its appium service can start the server for you, but Appium and the drivers still have to be installed. Mobilewright does not use Appium.

### Can I migrate from WebdriverIO to Mobilewright?

Yes, one spec at a time. $('~email') becomes getByTestId('email') or getByLabel('Email'), setValue becomes fill, tap stays tap, and expect(...).toBeDisplayed() becomes expect(...).toBeVisible(). describe and it become test.describe and test. The capabilities block becomes platform, bundleId and installApps in mobilewright.config.ts.

### Does WebdriverIO auto-wait on mobile?

Yes. Element commands wait for the element to exist, and expect-webdriverio matchers retry. Mobilewright also checks that the element is visible, enabled and stable before every action.

### Can Mobilewright test websites like WebdriverIO does?

No. Mobilewright tests iOS and Android apps, including web views inside them. For websites in a desktop or mobile browser, use WebdriverIO or Playwright.

### Do both work with cloud device farms?

Yes. WebdriverIO works with every cloud that speaks Appium. Mobilewright has drivers for Mobile Next Cloud, BrowserStack, Sauce Labs, TestingBot and TestMu AI.

### Is Mobilewright open source?

Yes. Mobilewright is open source under the Apache 2.0 license. WebdriverIO is open source under the MIT license and is an OpenJS Foundation project.

## Related comparisons

*   [**Mobilewright vs Appium** — A Playwright-style API for iOS & Android — auto-waiting, no servers, no XPath, built for AI agents.](/compare/mobilewright-vs-appium/)
*   [**Mobilewright vs Maestro** — Real TypeScript and a Playwright-style API — the power of code, with auto-waiting and AI-agent support built in.](/compare/mobilewright-vs-maestro/)
*   [**Mobilewright vs Detox** — Detox tests React Native from inside the app. Mobilewright tests any app from the outside, on simulators and real devices.](/compare/mobilewright-vs-detox/)
