
Product news and testing tips.
Maestro and Appium both automate mobile UI tests. Maestro uses declarative YAML with automatic waiting, reusable flows, JavaScript and local sharding; Appium uses WebDriver clients and platform drivers, offering broader language and infrastructure integration. Choose based on the devices and controls you need: Maestro supports Android hardware and iOS simulators, but not physical iOS devices. Appium with XCUITest supports real iOS devices with provisioning. Both can feed CI reporting: Maestro exports JUnit XML directly, while an Appium test runner supplies its reporter. Compare a representative journey before replacing a working suite.
Key takeaways
- The Maestro CLI is Apache 2.0 open source; Maestro Studio is free but closed source. Maestro Cloud is a separate paid execution service.
- Maestro shares flow syntax across native, React Native, Flutter and hybrid apps. App IDs, selectors, permissions and platform-specific behavior still need validation. Physical iOS devices are not supported.
- Maestro supports local parallel execution: --shard-split distributes flows and --shard-all repeats the collection across devices. The requested devices must already be ready.
- Maestro supports loops, conditions, reusable subflows and sandboxed JavaScript. Appium offers a broader choice of languages and libraries, not exclusive access to program logic.
- Maestro exports JUnit XML and local HTML reports. Appium reporting comes from the selected runner. The optional Qualflare wrapper adds captured steps and screenshots, with version and sharding limits.
- Qualflare is our product: it stores and analyzes uploaded results, not device execution. Local reporting remains useful; historical flaky classification and AI analysis have separate evidence and eligibility requirements.
Maestro and Appium are two cross-platform options for mobile UI automation. Maestro, maintained by mobile.dev (mobile-dev-inc on GitHub), starts with YAML flows and built-in waiting. Appium connects a language client to a server and platform driver through WebDriver. The useful question is which fits your target devices, existing infrastructure and required controls.
Both support parallel execution. Maestro can shard on local devices; Appium uses the selected runner, grid or device provider. A more decisive distinction is physical iOS support: Maestro supports iOS simulators, while Appium with XCUITest can automate real iOS devices after configuration and provisioning.
Method and disclosure: documentation checked November 7, 2026. This is not a hands-on speed benchmark. Qualflare is our product; its role here is optional result collection and history, not running tests or supplying devices.
What Maestro actually is
Maestro is an Apache 2.0 UI automation framework for Android, iOS and web. Its GitHub README distinguishes the open-source CLI from the free, closed-source Studio desktop app and the paid Maestro Cloud execution service. The CLI requires Java 17 or newer, and mobile execution needs a ready device and the app under test.
Both tools can exercise user-visible behavior without treating the app as a collection of unit tests. Maestro uses accessibility and input interfaces; Appium drivers use platform automation APIs. Appium does not inherently require access to application internals. Maestro also installs and communicates with a companion driver app on the device: “no separate Appium server to manage” is more precise than “no drivers exist.”
Shared Maestro syntax works across native, React Native, Flutter and hybrid apps, but app IDs, accessibility semantics and platform-specific interactions still matter. Identical YAML is not guaranteed to work unchanged on every build. Flutter’s own widget and integration tests can also report to Qualflare directly: qf collect reads the JSON output of flutter test (Flutter test reporting).
A mobile flow has a YAML header with an appId, a --- separator and commands such as launchApp, tapOn, inputText and assertVisible. Web flows use different target configuration. Reusable subflows, loops, conditions and JavaScript can extend a simple command list.
Why Maestro exists: the problem it solves
Appium separates Core, Drivers, Clients and optional Plugins. A local setup includes the server, a driver such as UiAutomator2 or XCUITest, and a client. Official clients include Java, Python, Ruby and .NET; JavaScript options include WebdriverIO. A hosted provider may manage the server and devices, so the operational burden depends on the chosen setup.
Maestro gives you one CLI entry point without separately configuring an Appium server or language client. Device setup remains: for example, an Android emulator or an iOS simulator configured through the platform tooling. Compare the complete path to a running test, not just the number of install commands.
Maestro automatically waits for routine UI conditions. That can reduce synchronization code, but it does not eliminate timing failures. Its extendedWaitUntil command supports explicit conditions and custom timeouts. Appium waiting behavior depends on the driver, client and runner; condition-based waits are not the same as scattering fixed sleeps through a suite.
For context, the Bitrise Mobile Insights 2025 release reports the share of teams experiencing any flakiness rising from 10% to 26% in its customer data. The report covers January 2022–June 2025; those dates describe the dataset, not explicitly assigned endpoints for the two percentages. This is a vendor dataset, not evidence that either framework causes or fixes industry-wide flakiness.
A Maestro flow, in YAML
Here is an illustrative .maestro/login.yaml. The app must expose the example identifiers; replace the app ID, selectors and test-account values with ones from your own test environment.
# .maestro/login.yaml
appId: com.example.app
---
- launchApp
- tapOn:
id: "login_button"
- tapOn:
id: "email_input"
- inputText: "[email protected]"
- tapOn:
id: "password_input"
- inputText: "test-password"
- tapOn:
id: "submit_button"
- assertVisible:
id: "welcome_label"
appId targets the installed package or bundle. The id selector maps to Android resource IDs or iOS accessibility identifiers; React Native test IDs and Flutter semantics need to be exposed appropriately. Text selectors are also supported, but changing labels or localization can break them. assertVisible fails if its condition is not met within the applicable timeout. Run locally with maestro test .maestro/login.yaml, or export JUnit XML:
maestro test --format junit --output maestro-results.xml .maestro/
Use a fresh output path for each real run. Maestro also offers local HTML reports, including a detailed format with steps, plus separate logs and screenshots. Those are useful for debugging before adding a hosted reporting service.
The same flow in Appium
Appium tests use a supported language and test runner; Python and Ruby do not become compiled Java tests. Here is an illustrative Java version using the same accessibility identifiers exposed by this example app:
UiAutomator2Options options = new UiAutomator2Options()
.setDeviceName("Pixel_7")
.setAppPackage("com.example.app")
.setAppActivity(".MainActivity");
AndroidDriver driver = new AndroidDriver(
new URL("http://127.0.0.1:4723"), options);
try {
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
wait.until(ExpectedConditions.elementToBeClickable(
AppiumBy.accessibilityId("login_button"))).click();
wait.until(ExpectedConditions.visibilityOfElementLocated(
AppiumBy.accessibilityId("email_input"))).sendKeys("[email protected]");
wait.until(ExpectedConditions.visibilityOfElementLocated(
AppiumBy.accessibilityId("password_input"))).sendKeys("test-password");
wait.until(ExpectedConditions.elementToBeClickable(
AppiumBy.accessibilityId("submit_button"))).click();
Assertions.assertTrue(wait.until(ExpectedConditions.visibilityOfElementLocated(
AppiumBy.accessibilityId("welcome_label"))).isDisplayed());
} finally {
driver.quit();
}
Imports, dependencies, runner setup, an installed app, a configured device and a running server are outside this snippet. Android accessibility IDs use exposed content descriptions; they are not automatically the same as resource IDs used by Maestro. This example assumes the app exposes matching values. Use the right selector for your app rather than mechanically copying identifiers.
- Synchronization: this Java example uses explicit conditions; Maestro supplies automatic waiting and optional explicit wait commands.
- Execution: the Appium client talks to a server URL; Maestro manages its device connection through the CLI.
- Reporting: this assertion uses JUnit. The selected runner/build tooling exports Appium test results, for example through Surefire or a WebdriverIO reporter.
Maestro supports runFlow, repeat, conditions, evalScript and runScript. Its JavaScript sandbox permits data handling and HTTP calls but not arbitrary Node.js libraries or local filesystem access. Appium gives you the language and library ecosystem of the client you choose. That is a more useful distinction than “logic versus no logic.”
Maestro vs Appium: the direct comparison
Both cover multiple platforms, but the supported targets and configuration differ. For the broader framework choice, see the full 4-way comparison.
| Maestro | Appium | |
|---|---|---|
| Test definition | YAML, reusable flows, sandboxed JavaScript | Supported language plus runner |
| Setup | CLI, Java 17+, ready target and app | Server or provider, driver, client, target and app |
| Logic | Loops, conditions, subflows; restricted scripting | Client language and libraries |
| Waiting | Automatic conditions; explicit waits when needed | Driver, client or runner strategy |
| Local parallelism | Split flows or repeat the collection across ready devices | Runner or grid manages sessions |
| Mobile hardware | Android devices; iOS simulators, not physical iOS | Android and iOS hardware with suitable drivers and setup |
| Reports | Native JUnit; local HTML and artifacts | Runner or build reporter and driver artifacts |
| Existing setup | Check target and provider compatibility | Retain compatible grids, clients and helpers |
| License | Apache 2.0 | Apache 2.0 |
Sources for the decision boundaries: Maestro platforms, local sharding, JavaScript and Appium real-iOS configuration. Repository star counts are not evidence of runtime reliability, suitability or accelerating adoption.
Running at scale, and where Appium still wins
Scale involves more than concurrent sessions: device availability, independent test data, artifact naming and provider compatibility can determine whether a suite is usable.
Maestro supports local sharding. Use --shard-split to distribute flows, or --shard-all to run the collection on each device. The requested devices must already be booted and ready. Keep test data isolated and artifact names distinct; parallel runs can overwrite identically named screenshots. Maestro Cloud handles managed device allocation and parallelization instead of requiring you to supply that infrastructure.
Appium concurrency comes from the runner and execution infrastructure. A working grid, compatible device provider and reusable fixtures can be valuable reasons to stay. Check the specific driver, OS, device and provider capabilities rather than assuming every Appium integration supports every target.
Choose by the constraint you actually have:
- Choose Appium for physical iOS requirements, particular driver-level controls, or existing language libraries and infrastructure that would be costly to replace.
- Choose Maestro when supported targets, readable flows, built-in synchronization and direct reports match the work. Validate accessibility and platform behavior on your actual app.
- Keep both during evaluation if replacing a working suite would remove useful coverage before the alternative is proven for those journeys.
Migrating from Appium: what actually transfers
Existing Appium scripts do not run unchanged in Maestro. Test intent and knowledge of the app can transfer, but selectors, setup/cleanup, device provisioning and CI configuration need validation. Reusable Appium helpers may become Maestro subflows or scripts; some library-dependent work may be better left in the existing suite.
Start with one important journey and define what a successful comparison means:
- Use the same app build, target configuration and initial state. Note any behavior that needs real hardware.
- Keep assertions and retry policy comparable; record authoring effort separately from execution time.
- Inspect failure evidence and cleanup. Confirm the reports preserve the cases, outcomes and artifacts you need.
- Keep stable test identity across subsequent runs before interpreting historical pass/fail behavior. A shared JUnit format alone does not make flake rates comparable.
The vendor comparison linked in Sources reports Wahed reducing authoring from 3–4 hours per test to 10–15 minutes, and Eneco reducing regression testing from 16 hours to under one hour. These are vendor-published customer reports, not controlled benchmarks or expected outcomes for your suite. This review did not establish an independent speed advantage.
Maestro Cloud vs Qualflare: two different layers
Maestro Cloud is a paid service for running flows on managed virtual devices. Its execution, reports and debugging features are useful whether or not you use another results platform.
Qualflare is our results-management product. It does not provision emulators, simulators or real devices. It collects supported reports, including exported Maestro JUnit XML, for run history alongside other frameworks. AI failure clustering and historical flaky classification are conditional, not guaranteed on the first upload.
Historical flaky classification defaults to at least 10 results within the last 25 launches, with a 30% minority pass/fail threshold. It differs from a passed-on-retry badge. Clustering needs project AI and an eligible plan; naming needs five failures, Starter holds two clusters workspace-wide, and Open Source excludes clustering. Starter includes 50 uploads and a separate 10 launch analyses per month; analysis also needs enabled AI and an active subscription. Uploaded screenshots, videos and traces expire after 30 days. The linked product docs in Sources detail these boundaries.
Getting Maestro results into Qualflare
Two paths retain different evidence. First complete the existing quickstart: create a project, install current qf and save a login alias such as my-project. The token selects the project; the alias is not a new project created by collection. The current format documentation targets qf 0.4.0.
The native reporter, qualflare-maestro, wraps maestro test and reads its outputs rather than installing a reporter plugin. It requires Maestro 2.6+; nested steps need 2.10+, and screenshot uploads need qf 0.1.24+. Use a fresh directory in a local shell:
brew install qualflare/tap/qualflare-maestro
report_dir="$(mktemp -d)"
qualflare-maestro -output-dir "$report_dir" -- maestro test .maestro/
Collect separately, including after a failed test run. First inspect parsed names/counts against that run, then upload once:
qf my-project collect "$report_dir" --dry-run --output json
qf my-project collect "$report_dir" --environment development
The wrapper writes captured commands, screenshots and metadata. An early Maestro error can become an unattributed failure case if the wrapper can capture it and write the report. This does not guarantee output after a forced termination or write failure. In CI, use an always-running collection step, a shared output path, and preserve the test exit status; do not let a successful upload turn a failed test job green.
Important wrapper limitations:
- It wraps
maestro test, notmaestro cloud, recording or continuous runs. - It owns
--format,--output,--debug-outputand--flatten-debug-output; passing them yourself is an error. - It leaves no persistent JUnit file for a CI viewer. Use direct JUnit export below if that output is required.
- Duplicate flow names or a flow repeated across devices with
--shard-allcan make artifact attribution ambiguous; those cases keep results but lose steps/screenshots. Do not assume local sharding means full wrapper fidelity.
The direct path preserves Maestro JUnit XML for your existing CI/report viewer. Choose a fresh destination, run Maestro, then parse and collect the XML separately:
xml_dir="$(mktemp -d)"
maestro test --format junit --output "$xml_dir/maestro-results.xml" .maestro/
qf my-project collect "$xml_dir/maestro-results.xml" --format maestro --dry-run --output json
After verifying fresh, nonempty output and matching results:
qf my-project collect "$xml_dir/maestro-results.xml" --format maestro --environment development
Keep --format maestro on parsing and upload so the launch is labelled Maestro; unflagged XML with the ordinary suite root is labelled plain JUnit. XML contains flow results and can carry properties or Cloud links, but not the full separate step/screenshot bundle. An early failure can prevent the XML file from being written. Cloud-exported JUnit can use this collection path; the wrapper does not execute Cloud jobs.
The parser shares the JUnit route used for other converted mobile results (see unifying Android + iOS test results). For existing CI wiring and emulator troubleshooting, use the Maestro test reporting guide alongside the current collection docs. Local execution and local reports remain valid starting points; CI is not required for a useful first result.
For the broader picture of Android/iOS test management beyond any single framework, see the mobile testing complete guide.
Frequently asked questions
What is Maestro used for?
Maestro automates UI journeys such as login, checkout and onboarding using YAML flows. It supports Android emulators and physical devices, iOS simulators and web browsers, including apps built with React Native and Flutter. Physical iOS devices are not supported.
Is Maestro free?
The Maestro CLI is free and open source under Apache 2.0. Maestro Studio is free but closed source. Maestro Cloud is a separate paid service for managed execution. Local sharding does not require Cloud, but you provide the ready devices and compute.
Does Maestro replace Appium?
Not universally. Maestro is a fit for teams that prefer YAML flows, automatic waiting and direct report export on supported targets. Appium remains a fit for real iOS devices, specific driver capabilities, existing grids and reusable language-based test infrastructure. Evaluate the required journeys before replacing a working suite.
Does Maestro support React Native and Flutter apps?
Yes. Maestro uses the UI accessibility layer, with shared commands across React Native, Flutter and native apps. That does not guarantee an unchanged flow across builds: accessible identifiers, app IDs, permissions and platform behavior must match or be handled explicitly.
Can I reuse my Appium scripts in Maestro?
Existing Appium scripts do not run unchanged in Maestro. Re-express the journey as flows and validate selectors, setup, assertions and cleanup. Test intent can transfer, but device provisioning and CI configuration may need changes. Keep the existing suite while evaluating a small comparable set of flows.
Is Maestro faster than Appium?
This documentation review does not establish an independent speed advantage. Vendor-published case studies are not controlled head-to-head benchmarks. Compare authoring effort and execution time separately, using the same app build, target configuration, initial state and retry policy. Both tools can run tests in parallel.
What is Maestro Cloud, and is it the same as Qualflare?
No. Maestro Cloud executes flows on managed virtual devices. Qualflare, our product, collects supported results for reporting and cross-run history; it does not provision devices or execute tests. Cloud-exported JUnit can be collected separately. The Qualflare wrapper supports maestro test, not maestro cloud, and history-based classification and AI features have prerequisites.
Does Maestro produce JUnit-XML for CI reporting?
Yes. Run maestro test with --format junit and --output to choose the XML file. JUnit carries flow results and can include properties; detailed steps and screenshots are separate artifacts. Maestro also offers local HTML reports. An early failure can prevent XML generation, so check that the expected fresh report exists before collecting it.
Sources
- Maestro Docs — Documentation
- Maestro Docs — Test Reports and Artifacts
- GitHub — mobile-dev-inc/maestro
- Maestro — Appium vs Maestro (vendor comparison and customer case studies)
- Appium — Introduction to Appium
- Bitrise — Mobile Insights Report 2025
- Maestro Docs — Local devices and sharding
- Maestro Docs — Supported platforms
- Maestro Docs — How Maestro works
- Maestro Docs — JavaScript overview
- Maestro Docs — Core selectors
- Maestro Docs — extendedWaitUntil
- Appium — Clients
- Appium XCUITest — Real-device configuration
- Qualflare Maestro reporter — Configuration
- Qualflare Maestro reporter — Limitations
- Qualflare — Quickstart
- Qualflare — Collect results
- Qualflare — Supported formats
- Qualflare — Flaky tests
- Qualflare — Failure clusters
- Qualflare — Launch analysis


