What’s New in Appium 3: Key Features and Enhancements

Appium 3 Advancements: At a Glance

Here’s what’s new and improved in Appium 3:

• Node.js and npm Requirements: Appium now requires Node.js 20.19 or higher and npm 10 or higher.
• Deprecated Endpoints Removed: Many deprecated endpoints have been removed. Commands like app launching or closing are now handled directly by specific drivers such as UiAutomator2 or XCUITest.
• Feature Flag Prefixes Mandate: Feature flag prefixes are now mandatory. For example, instead of adbshell, you now use uiautomator2:adbshell. This change prevents insecure features from running across multiple drivers by mistake.
• Session Discovery Flag Added: A new session discovery flag has been added. To view all active sessions, you’ll now use GET /appium/sessions instead of GET /sessions, with the session_discovery feature enabled.
• Inspector Plugin Integration: Appium Inspector can now be installed and hosted directly through Appium. You just need to run the command below:

appium plugin install inspector

This removes the need for a separate Inspector app.

• Sensitive Data Masking: Appium now supports sensitive data masking. You can use the X-Appium-Is-Sensitive HTTP header to hide passwords or tokens in logs.
• Driver-Specific Unzip Logic: The unzip logic used for handling app files has been moved to individual drivers, keeping the core lighter and easier to maintain.
• Express 5 Upgrade: The internal web framework has been upgraded to Express 5, which improves performance and keeps the server up to date.

What Are the New Features and Enhancements in Appium 3?

Appium 3 introduces support for Node 20, drops deprecated endpoints, enforces feature flag prefixes, improves session discovery, and adds the Inspector plugin. It also masks sensitive data, moves unzip handling to drivers, updates to Express 5, sharpens W3C compliance, and improves error and log handling.

Let’s explore the Appium 3 advancements and features that can streamline your workflow and reduce maintenance effort.

1. Node.js 20 and npm 10 Required

One of the most visible changes is that Appium now requires Node.js 20.19.0 or higher and npm 10 or higher. This means Appium is finally aligned with the latest long-term supported versions of Node, giving you better performance and stronger security.

If you’ve been using older Node versions, you’ll need to upgrade before installing Appium 3. You can check your current versions with the following commands:

node -v

npm -v

Then install or upgrade Appium globally with:

npm install -g appium

What Testers Need to Do:

• Upgrade your Node.js and npm if they are outdated.
• Reinstall Appium globally to ensure compatibility.

What Driver/Plugin Developers Need to Do:

• Verify that any embedded Node projects or custom middleware are compatible with the updated environment.
• Ensure drivers and plugins work with Express 5, which is now part of Appium 3.

Note: Run Appium 3 tests on real Android and iOS devices. Try LambdaTest Now!

2. Deprecated Endpoints Removed

Appium has supported a lot of endpoints over the years, including some that were outdated or duplicated. In Appium 3, these deprecated endpoints have finally been removed.

This cleanup keeps the server lighter and reduces confusion between the old JSON Wire Protocol (JSONWP) and the W3C WebDriver standard. Now, actions like launching, closing, or resetting an app are handled directly by the drivers.

For example, instead of using an old endpoint like /session/:sessionId/appium/app/launch, you’ll now use:

mobile: launchApp

mobile: terminateApp

mobile: startActivity

What Testers Need to Do:

• Check your test scripts for deprecated endpoints.
• Replace any old JSONWP endpoints with the corresponding driver-specific commands (mobile: launchApp, mobile: terminateApp, mobile: startActivity).
• Ensure automated tests continue to work without relying on removed endpoints.

What Driver/Plugin Developers Need to Do:

• Migrate any legacy logic from the core server to the driver, where these commands are now handled.
• Ensure the driver correctly implements app launch, termination, and activity commands.
• Verify compatibility with both existing client libraries and the W3C WebDriver standard.

Tip: Check your client libraries or frameworks for any older endpoints and replace them with these newer methods.

3. Feature Flag Prefix Now Mandatory

In earlier versions of Appium, you could enable certain experimental or “insecure” features globally with a command like this:

appium --allow-insecure=adb_shell

While this made configuration easier, it also carried a risk. A flag meant for one driver could affect others unintentionally.

Appium 3 fixes this by requiring a driver prefix for each flag. That means you now have to specify which driver the feature belongs to.

You can do this by running the following command:

appium --allow-insecure=uiautomator2:adb_shell

If you want to keep the old behavior and enable a feature for all drivers, you can still use a wildcard:

appium --allow-insecure=*:adb_shell

This change might seem small, but it adds an important layer of safety and clarity, especially when performing Appium mobile testing across different platforms.

What Testers Need to Do:

• Update your Appium commands to include driver prefixes for any experimental or insecure features.
• Use the wildcard option only if you intentionally want a feature enabled across all drivers.
• Check existing test scripts and CI/CD pipelines to ensure compatibility with the new prefix requirement.

What Driver/Plugin Developers Need to Do:

• Ensure that your driver correctly handles prefixed feature flags.
• Validate that no insecure feature for one driver can inadvertently affect others.
• Update driver or plugin documentation to reflect the new feature flag format.

4. Session Discovery Requires a Feature Flag

Previously, you could list all active sessions using the /sessions endpoint. In Appium 3, this endpoint has been replaced with /appium/sessions, and a new feature flag now protects it.

To use it, you need to launch the server with:

appium --allow-insecure=*:session_discovery

The response now includes a created field that shows when each session started, making it easier to track session activity and troubleshoot tests.

This new approach adds structure and ensures session details are retrieved securely, rather than exposed by default.

What Testers Need to Do:

• Enable the session_discovery feature flag to list active sessions.
• Use the new /appium/sessions endpoint instead of /sessions.
• Leverage the created timestamp to monitor session activity and debug tests efficiently.

What Driver/Plugin Developers Need to Do:

• Ensure your driver correctly reports session creation times and other session metadata.
• Verify that the /appium/sessions endpoint returns accurate and complete information for all active sessions.
• Maintain security by ensuring that session discovery only works when the feature flag is enabled.

5. Appium Inspector Can Now Be Installed as a Plugin

You no longer need to download the Appium Inspector separately. With Appium 3, you can install and host it directly from the Appium Server:

appium plugin install inspector

Once installed, you can open the Inspector in your browser and start inspecting elements. This integration saves time and keeps your testing workflow unified inside the Appium environment.

What Testers Need to Do:

• Install the Inspector plugin directly from Appium Server to simplify your workflow.
• Open the Inspector in your browser to inspect elements without using a separate app.
• Take advantage of the unified environment to streamline test creation and debugging.

What Driver/Plugin Developers Need to Do:

• Ensure your driver or plugin is fully compatible with the Inspector plugin.
• Validate that element inspection, commands, and driver responses are accurately reflected in the Inspector.
• Maintain proper lifecycle integration so the Inspector starts, stops, and communicates reliably with the server and drivers.

6. Sensitive Data Masking in Logs

A common challenge in testing is exposing sensitive data like passwords in logs. Appium 3 introduces a new way to mask such information. By adding the X-Appium-Is-Sensitive header to your client request, any sensitive input (like credentials or tokens) will appear as hidden values in the logs instead of plaintext.

This change is especially valuable for CI/CD pipelines or shared environments where logs are accessible to multiple users.

What Testers Need to Do:

• Use the X-Appium-Is-Sensitive header when sending sensitive information, such as passwords or API tokens.
• Verify that sensitive data no longer appears in server or driver logs.
• Apply this practice in CI/CD pipelines to prevent accidental exposure in shared logs.

What Driver/Plugin Developers Need to Do:

• Ensure your driver or plugin respects the X-Appium-Is-Sensitive header and properly masks sensitive values.
• Maintain consistency across different drivers so that sensitive data is always protected in logs.
• Update logging mechanisms to prevent any accidental plaintext output for sensitive fields.

7. Unzip Logic Moved to Drivers

In legacy versions, Appium handled app installation files directly within the core, including unzip operations for packages. That logic has now been removed from the core and moved to specific drivers like UiAutomator2 and XCUITest.

This separation keeps Appium modular and ensures that platform-specific code lives where it belongs. To take advantage of this, make sure your drivers are up to date:

appium driver update --all

What Testers Need to Do:

• Update all your drivers using appium driver update --all to ensure app installation works correctly.
• Verify that your test scripts still install and launch apps as expected.
• No changes are needed in your test scripts unless you were relying on old core behavior for file handling.

What Driver/Plugin Developers Need to Do:

• Implement unzip and app installation logic within the driver rather than the core.
• Ensure platform-specific handling is correct for each driver (Android vs iOS).

Maintain compatibility with Appium 3’s modular architecture so drivers function independently of core logic.

8. Express Framework Upgraded to Version 5

Appium’s internal server is built on the Express web framework. In Appium 3, Express has been upgraded from version 4 to version 5. This update improves performance and modernizes the server foundation, ensuring compatibility with the latest Node.js versions.

You don’t need to change anything on your end - this upgrade happens automatically when you install Appium 3. But if you’ve embedded Appium in a custom Node project, it’s worth noting the version change.

What Testers Need to Do:

• No action is required for standard test execution.
• Tests will continue to run as before, benefiting from improved server performance automatically.

What Driver/Plugin Developers Need to Do:

• Check that any custom middleware, embedded Node projects, or server extensions are compatible with Express 5.
• Test plugins and drivers to ensure async operations and request handling still work correctly with the upgraded framework.
• Update any documentation or examples referencing Express 4 to reflect the new version.

9. Cleaner W3C WebDriver Compliance

Appium 3 continues the shift toward full W3C WebDriver compliance. The framework has dropped leftover support for old JSON Wire Protocol parameters that were still lingering in Appium 2.

This means your tests will now behave more consistently across browsers, devices, and client libraries. It also makes Appium’s communication with modern automation tools cleaner and more predictable.

What Testers Need to Do:

• Expect your test scripts to behave more consistently across different browsers and devices.
• Check test scripts if you were relying on deprecated JSON Wire Protocol parameters, and update them to use standard W3C WebDriver commands.
• Benefit from improved predictability when integrating with modern client libraries and automation tools.

What Driver/Plugin Developers Need to Do:

• Remove any lingering JSON Wire Protocol handling in drivers or plugins.
• Ensure full compliance with W3C WebDriver standards in all command handling and responses.
• Test drivers and plugins thoroughly with W3C-compliant clients to maintain cross-platform consistency.

10. Improved Error and Log Handling

Appium 3 improves the way errors are reported and logged. When something fails, the log now shows which component caused the issue - whether it’s the core server, a plugin, or a specific driver.

This clear separation makes debugging much faster. You can pinpoint the source of a problem without digging through hundreds of lines of logs. It’s one of those changes you’ll appreciate the first time something goes wrong in a large test suite.

What Testers Need to Do:

• Use the improved logs to quickly identify whether an issue originates from the server, a driver, or a plugin.
• Spend less time debugging large test suites because error sources are clearly separated.
• Incorporate this enhanced logging into CI/CD pipelines for faster troubleshooting.

What Driver/Plugin Developers Need to Do:

• Ensure your drivers and plugins report errors correctly so they appear in the logs with accurate component context.
• Maintain structured error messages and stack traces to help testers pinpoint issues efficiently.
• Check logging in custom plugins or extended drivers to ensure compatibility with Appium 3’s new error reporting format.

Appium 3 vs Appium 2: A Quick Comparison

Appium 3 needs Node 20, removes deprecated endpoints, adds a flagged sessions API, plugin Inspector, data masking, driver unzip, Express 5, and better errors. Appium 2 uses older Node, keeps old endpoints, and lacks these updates.

Here is a quick comparison of Appium 3 and Appium 2, highlighting changes in drivers, feature flags, Inspector setup, endpoints, and other updates.

How LambdaTest Simplifies Appium 3 Mobile Testing?

Running your mobile tests across multiple devices and platforms can be challenging, especially with local test infrastructure. Platforms like LambdaTest offer cloud mobile testing with instant access to hundreds of real and virtual devices, allowing you to run Appium 3 test scripts on real devices.

Key Features:

• Access to Mobile Devices on Cloud: Run your Appium 3 mobile tests on hundreds of Android and iOS devices instantly, eliminating the need for a local device lab or physical devices.
• Cross-Device & Platform Testing: Validate that your mobile app works consistently across multiple OS versions, screen sizes, and device models without manual setup.
• Parallel Test Execution: Execute multiple Appium 3 tests in parallel on different devices to ensure faster time to market.

Note: LambdaTest supports Appium 3 on Android 15+ and iOS 16+ on its virtual device cloud.

To get started, check out this guide on Appium testing with LambdaTest.

You can generate Appium 3 capabilities from the LambdaTest Automation Capability Generator.

Conclusion

Appium 3 doesn’t completely change how you write or run tests, but it does refine the foundation the framework runs on. The focus of this release is cleanup and alignment - removing outdated endpoints, tightening feature flag usage, and ensuring better compatibility with modern Node.js and npm versions.

You’ll notice small but valuable updates across the board. The Inspector is easier to install, logs are more secure, and commands now behave more consistently across drivers. By moving unzip logic and other driver-specific operations out of the core, Appium is now lighter and simpler to maintain.

If you’re currently on Appium 2, upgrading isn’t a heavy lift. Most of your existing scripts will still work, though you’ll want to double-check feature flags, updated endpoints, and your Node environment. Taking the time to make those adjustments now will help you avoid compatibility issues later and keep your automation setup aligned with the latest driver standards.

New to Appium? Check out this detailed Appium tutorial.

Citations

• Appium 3 Blog: https://appium.io/docs/en/3.0/blog/2025/08/07/-appium-3/
• Migrating to Appium 3 Documentation: https://appium.io/docs/en/3.0/guides/migrating-2-to-3/