# Appium testing in AWS Device Farm
During a remote access session, you can run Appium tests from your local environment, targeting the session's device using a managed Appium endpoint. With an Appium endpoint, you're able to develop, test, and execute Appium code with fast feedback and rapid iteration. This **client-side** approach to testing offers the flexibility to connect to a Device Farm device from any Appium client environment of your choice.
To complement client-side testing, Device Farm also supports running tests on infrastructure managed by the service, called **server-side** execution. In this approach, you can upload your app and tests to the service, then executes the tests in parallel on multiple devices using service-managed [test hosts](custom-test-environments-hosts.md). This approach scales well for testing on many devices independently, as well as testing from the context of a CI/CD pipeline.
To learn more about server-side execution, please see [Test frameworks and built-in tests in AWS Device Farm](test-types.md).
**Topics**
+ [What is an Appium endpoint?](#appium-endpoint-what-is)
+ [Getting started with Appium testing](appium-endpoint-getting-started.md)
+ [Interacting with the device using Appium](appium-endpoint-interaction.md)
+ [Reviewing your Appium server logs](appium-endpoint-server-logs.md)
+ [Supported Appium capabilities and commands](appium-endpoint-supported-caps-and-commands.md)
## What is an Appium endpoint?
[Appium](https://appium.io/) is a popular open-source software testing framework for testing native, hybrid, and mobile web applications on different devices, including mobile phones and tablets, for both iOS and Android. It allows developers and QA (Quality Assurance) engineers to write scripts that can remotely control a device, simulate user interactions, and verify that the application under test is behaving as expected. Appium interacts with apps from the perspective of an end-user, enabling testers to develop tests that simulate how real users will use the app for their tests.
Appium is built on the client-server model, where a local client requests a (local or remote) Appium server to command a device on their behalf. The Appium server manages a driver for communicating with the device, such as the [UIAutomator2 driver](https://github.com/appium/appium-uiautomator2-driver/) for Android or the [XCUITest driver](https://appium.github.io/appium-xcuitest-driver/9.10/) for iOS. All commands follow the [W3C WebDriver](https://www.w3.org/TR/webdriver2/) standards for how to control a device.
Device Farm's Appium endpoint exposes an Appium server URL for the device in your remote access session. The Appium endpoint URL will be specific to that device in that session, and remain valid for the duration of the session, allowing you to iterate on the same device without additional setup time. For more information about Remote Access, please see [Remote access in AWS Device Farm](remote-access.md).
# Getting started with Appium testing
For most Appium users, using Device Farm for Appium testing requires only minor changes to your existing test configuration.
At a high level, there are three steps to using Device Farm for client-side Appium tests:
1. First, you need to [create a remote access session](how-to-create-session.md) for testing a Device Farm device. You can include your apps as a part of your remote access request, or install apps after the session has started.
1. Once the session is running, you can [copy the Appium endpoint URL](appium-endpoint-interaction.md), and use it either through a stand-alone tool (like [Appium Inspector](https://github.com/appium/appium-inspector)) or from your Appium test code in your IDE. The URL will be valid for the duration of the remote access session.
1. And finally, once your Appium test has started, you can [review your Appium server logs](appium-endpoint-server-logs.md) live during the test execution alongside the video stream of your device.
# Interacting with the device using Appium
Once you've [created a remote access session](how-to-create-session.md), the device will be available for Appium testing. For the entire duration of the remote access session, you can run as many Appium sessions as you'd like on the device, with no limits on what clients you use. For example, you can start by running a test using your local Appium code from your IDE, then switch over to using Appium Inspector to troubleshoot any issues you encounter. The session can last up to [150-minutes](limits.md#service-limits), however, if there is no activity for over 5 minutes (either through the interactive console or through the Appium endpoint), the session will time out.
## Using apps for testing with your Appium session
There are several ways to provide an app for use with your Appium session:
+ Upload an app to Device Farm and install it in the session.
+ Specify an HTTPS URL or Amazon S3 URI as the `appium:app` capability.
+ Reference an already-installed app by its package name (using `appium:appPackage` on Android or `appium:bundleId` on iOS).
+ Test a web app by specifying the `browserName` capability (`Chrome` on Android, `Safari` on iOS).
Standard [app size limits](limits.md#file-limits) (4 GB) apply to all app sources.
**Note**
Device Farm does not support passing a local filesystem path in `appium:app` during a remote access session.
### Uploading, installing, and using apps
To use an uploaded app with your Appium session, follow these steps:
1.
**Upload and install your app**
There are two ways to upload and install an app onto the device under test:
+ Include the app ARN in your [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateRemoteAccessSession.html) request. The app is automatically installed onto the device when the session starts. You can also include auxiliary app ARNs, which will be installed alongside the primary app.
+ Install the app during an active session using the [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_InstallToRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_InstallToRemoteAccessSession.html) API, or by uploading it through the Device Farm console. This allows you to change the app under test without creating a new session.
1.
**Use the installed app**
Once installed, the app is automatically injected as the default `appium:app` capability for any subsequent Appium sessions. If you included auxiliary apps, they are set as the `appium:otherApps` capability.
For example, if you create a remote access session using `com.aws.devicefarm.sample` as your app, and `com.aws.devicefarm.other.sample` as one of your auxiliary apps, then when you go to create an Appium session, it will have capabilities similar to the following:
```
{
"value":
{
"sessionId": "abcdef123456-1234-5678-abcd-abcdef123456",
"capabilities":
{
"app": "/tmp/com.aws.devicefarm.sample.apk",
"otherApps": "[\"/tmp/com.aws.devicefarm.other.sample.apk\"]",
...
}
}
}
```
If you install a new app during the session, it replaces the current `appium:app` capability. If the previously installed app has a distinct package name, it remains on the device and moves to the `appium:otherApps` capability.
For example, if you initially use `com.aws.devicefarm.sample` when creating your remote access session, but then install `com.aws.devicefarm.other.sample` during the session, then your Appium sessions will have capabilities similar to the following:
```
{
"value":
{
"sessionId": "abcdef123456-1234-5678-abcd-abcdef123456",
"capabilities":
{
"app": "/tmp/com.aws.devicefarm.other.sample.apk",
"otherApps": "[\"/tmp/com.aws.devicefarm.sample.apk\"]",
...
}
}
}
```
**Note**
For more information about automatically uploading apps as a part of your remote access session, please see [automating app uploads.](api-ref.md#upload-example)
### Using an HTTPS URL
You can specify a publicly accessible HTTPS URL as the `appium:app` desired capability when creating an Appium session. The URL must point directly to a downloadable app file (for example, an `.apk` or `.ipa` file). Device Farm downloads the app from the specified URL and installs it onto the device under test.
**Important**
Only HTTPS URLs are supported. Plain HTTP URLs are rejected.
For example, the following Appium session creation request downloads an app from an HTTPS URL:
```
{
"capabilities":
{
"alwaysMatch": {},
"firstMatch":
[
{
"appium:app": "https://example.com/path/to/MyApp.apk"
}
]
}
}
```
### Using an Amazon S3 URI
You can specify an Amazon S3 URI (for example, `s3://my-bucket/path/to/MyApp.ipa`) as the `appium:app` desired capability when creating an Appium session. Device Farm downloads the app from the specified S3 location and installs it onto the device under test.
To use an S3 URI, the following requirements must be met:
+ The remote access session must be started from a project that has an [IAM execution role](custom-test-environments-iam-roles.md) configured.
+ The IAM execution role must have a maximum session duration of at least 150 minutes, because the role is assumed for the duration of the remote access session.
+ The IAM execution role must have permission to call `s3:GetObject` on the S3 object specified in the URI. We also recommend granting `s3:HeadObject` permission on the same object, which allows Device Farm to validate the object's existence before attempting the download.
For example, the following Appium session creation request downloads an app from an S3 URI:
```
{
"capabilities":
{
"alwaysMatch": {},
"firstMatch":
[
{
"appium:app": "s3://my-test-bucket/apps/MyApp.ipa"
}
]
}
}
```
The following is an example IAM permissions policy that grants the recommended access for downloading an app from Amazon S3, including the optional `s3:HeadObject` permission. For more information about configuring IAM execution roles, see [Access AWS resources using an IAM Execution Role](custom-test-environments-iam-roles.md).
**Example**
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:HeadObject"
],
"Resource": "arn:aws:s3:::my-test-bucket/apps/*"
}
]
}
```
### Using an already-installed app
If the app you want to test is already installed on the device, you can reference it directly by its package name instead of uploading it. Use the `appium:appPackage` and `appium:appActivity` capabilities on Android, or the `appium:bundleId` capability on iOS.
For example, the following Appium session creation request launches an already-installed Android app:
```
{
"capabilities":
{
"alwaysMatch": {},
"firstMatch":
[
{
"appium:appPackage": "com.example.myapp",
"appium:appActivity": "com.example.myapp.MainActivity"
}
]
}
}
```
On iOS, use `appium:bundleId` instead:
```
{
"capabilities":
{
"alwaysMatch": {},
"firstMatch":
[
{
"appium:bundleId": "com.example.myapp"
}
]
}
}
```
### Testing a web app
To test a web app, specify the `browserName` capability in your Appium session creation request. Use `Chrome` on Android devices or `Safari` on iOS devices.
For example, the following request opens Chrome on an Android device:
```
{
"capabilities":
{
"alwaysMatch": {},
"firstMatch":
[
{
"browserName": "Chrome"
}
]
}
}
```
## How to use the Appium endpoint
Here are the steps to access the session's Appium endpoint from the console, the AWS CLI, and the AWS SDKs. These steps include how to get started with running tests using various Appium client testing frameworks:
------
#### [ Console ]
1. Open your remote access session page in your web browser:
![\[\]](http://docs.aws.amazon.com/devicefarm/latest/developerguide/images/aws-device-farm-appium-endpoint.png)
1. For running a session using Appium Inspector, do the following:
1. Click the button **Setup Appium session**
1. Follow along with the instructions on the page for how to start a session using Appium Inspector.
1. For running an Appium test from your local IDE, do the following:
1. Click the "copy" icon next to the text **Appium endpoint URL**
1. Paste this URL into your local Appium code wherever you currently specify your remote address or command executor. For language-specific examples, please click one of the tabs in this example window for your language of choice.
------
#### [ AWS CLI ]
First, verify that your AWS CLI version is up-to-date by [downloading and installing the latest version](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
**Important**
The Appium endpoint field isn't available in older versions of the AWS CLI.
Once your session is up and running, the Appium endpoint URL will be available via a field named `remoteDriverEndpoint` in the response to a call to the [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html) API:
```
$ aws devicefarm get-remote-access-session \
--arn "arn:aws:devicefarm:us-west-2:123456789876:session:abcdef123456-1234-5678-abcd-abcdef123456/abcdef123456-1234-5678-abcd-abcdef123456/00000"
```
This will show output such as the following:
```
{
"remoteAccessSession": {
"arn": "arn:aws:devicefarm:us-west-2:111122223333:session:abcdef123456-1234-5678-abcd-abcdef123456/abcdef123456-1234-5678-abcd-abcdef123456/00000",
"name": "Google Pixel 8",
"status": "RUNNING",
"endpoints": {
"remoteDriverEndpoint": "https://devicefarm-interactive-global.us-west-2.api.aws/remote-endpoint/ABCD1234...",
...
}
```
You can use this URL in your local Appium code wherever you currently specify your remote address or command executor. For language-specific examples, please click one of the tabs in this example window for your language of choice.
For an example of how to interact with the endpoint directly from the command line, you can use the [command-line tool curl](https://curl.se/) to call a WebDriver endpoint directly:
```
$ curl "https://devicefarm-interactive-global.us-west-2.api.aws/remote-endpoint/ABCD1234.../status"
```
This will show output such as the following:
```
{
"value":
{
"ready": true,
"message": "The server is ready to accept new connections",
"build":
{
"version": "2.5.1"
}
}
}
```
------
#### [ Python ]
Once your session is up and running, the Appium endpoint URL will be available via a field named `remoteDriverEndpoint` in the response to a call to the [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html) API:
```
# To get the URL
import sys
import boto3
from botocore.exceptions import ClientError
def get_appium_endpoint() -> str:
session_arn = "arn:aws:devicefarm:us-west-2:111122223333:session:abcdef123456-1234-5678-abcd-abcdef123456/abcdef123456-1234-5678-abcd-abcdef123456/00000"
device_farm_client = boto3.client("devicefarm", region_name="us-west-2")
try:
resp = device_farm_client.get_remote_access_session(arn=session_arn)
except ClientError as exc:
sys.exit(f"Failed to call Device Farm: {exc}")
remote_access_session = resp.get("remoteAccessSession", {})
endpoints = remote_access_session.get("endpoints", {})
endpoint = endpoints.get("remoteDriverEndpoint")
if not endpoint:
sys.exit("Device Farm response did not include endpoints.remoteDriverEndpoint")
return endpoint
# To use the URL
from appium import webdriver
from appium.options.android import UiAutomator2Options
opts = UiAutomator2Options()
driver = webdriver.Remote(get_appium_endpoint(), options=opts)
# ...
driver.quit()
```
------
#### [ Java ]
*Note: this example uses the AWS SDK for Java v2, and is compatible with JDK versions 11 and higher.*
Once your session is up and running, the Appium endpoint URL will be available via a field named `remoteDriverEndpoint` in the response to a call to the [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html) API:
```
// To get the URL
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.devicefarm.DeviceFarmClient;
import software.amazon.awssdk.services.devicefarm.model.GetRemoteAccessSessionRequest;
import software.amazon.awssdk.services.devicefarm.model.GetRemoteAccessSessionResponse;
public class AppiumEndpointBuilder {
public static String getAppiumEndpoint() throws Exception {
String session_arn = "arn:aws:devicefarm:us-west-2:111122223333:session:abcdef123456-1234-5678-abcd-abcdef123456/abcdef123456-1234-5678-abcd-abcdef123456/00000";
try (DeviceFarmClient client = DeviceFarmClient.builder()
.region(Region.US_WEST_2)
.credentialsProvider(DefaultCredentialsProvider.create())
.build()) {
GetRemoteAccessSessionResponse resp = client.getRemoteAccessSession(
GetRemoteAccessSessionRequest.builder().arn(session_arn).build()
);
String endpoint = resp.remoteAccessSession().endpoints().remoteDriverEndpoint();
if (endpoint == null || endpoint.isEmpty()) {
throw new IllegalStateException("remoteDriverEndpoint missing from response");
}
return endpoint;
}
}
}
// To use the URL
import io.appium.java_client.android.AndroidDriver;
import io.appium.java_client.android.options.UiAutomator2Options;
import java.net.URL;
public class ExampleTest {
public static void main(String[] args) throws Exception {
String endpoint = AppiumEndpointBuilder.getAppiumEndpoint();
UiAutomator2Options options = new UiAutomator2Options();
AndroidDriver driver = new AndroidDriver(new URL(endpoint), options);
try {
// ... your test ...
} finally {
driver.quit();
}
}
}
```
------
#### [ JavaScript ]
*Note: this example uses AWS SDK for JavaScript v3 and WebdriverIO v8\$1 using Node 18\$1.*
Once your session is up and running, the Appium endpoint URL will be available via a field named `remoteDriverEndpoint` in the response to a call to the [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html) API:
```
// To get the URL
import { DeviceFarmClient, GetRemoteAccessSessionCommand } from "@aws-sdk/client-device-farm";
export async function getAppiumEndpoint() {
const sessionArn = "arn:aws:devicefarm:us-west-2:111122223333:session:abcdef123456-1234-5678-abcd-abcdef123456/abcdef123456-1234-5678-abcd-abcdef123456/00000";
const client = new DeviceFarmClient({ region: "us-west-2" });
const resp = await client.send(new GetRemoteAccessSessionCommand({ arn: sessionArn }));
const endpoint = resp?.remoteAccessSession?.endpoints?.remoteDriverEndpoint;
if (!endpoint) throw new Error("remoteDriverEndpoint missing from response");
return endpoint;
}
// To use the URL with WebdriverIO
import { remote } from "webdriverio";
(async () => {
const endpoint = await getAppiumEndpoint();
const u = new URL(endpoint);
const driver = await remote({
protocol: u.protocol.replace(":", ""),
hostname: u.hostname,
port: u.port ? Number(u.port) : (u.protocol === "https:" ? 443 : 80),
path: u.pathname + u.search,
capabilities: {
platformName: "Android",
"appium:automationName": "UiAutomator2",
// ...other caps...
},
});
try {
// ... your test ...
} finally {
await driver.deleteSession();
}
})();
```
------
#### [ C\$1 ]
Once your session is up and running, the Appium endpoint URL will be available via a field named `remoteDriverEndpoint` in the response to a call to the [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html) API:
```
// To get the URL
using System;
using System.Threading.Tasks;
using Amazon;
using Amazon.DeviceFarm;
using Amazon.DeviceFarm.Model;
public static class AppiumEndpointBuilder
{
public static async Task GetAppiumEndpointAsync()
{
var sessionArn = "arn:aws:devicefarm:us-west-2:111122223333:session:abcdef123456-1234-5678-abcd-abcdef123456/abcdef123456-1234-5678-abcd-abcdef123456/00000";
var config = new AmazonDeviceFarmConfig
{
RegionEndpoint = RegionEndpoint.USWest2
};
using var client = new AmazonDeviceFarmClient(config);
var resp = await client.GetRemoteAccessSessionAsync(new GetRemoteAccessSessionRequest { Arn = sessionArn });
var endpoint = resp?.RemoteAccessSession?.Endpoints?.RemoteDriverEndpoint;
if (string.IsNullOrWhiteSpace(endpoint))
throw new InvalidOperationException("RemoteDriverEndpoint missing from response");
return endpoint;
}
}
// To use the URL
using OpenQA.Selenium.Appium;
using OpenQA.Selenium.Appium.Android;
class Example
{
static async Task Main()
{
var endpoint = await AppiumEndpointBuilder.GetAppiumEndpointAsync();
var options = new AppiumOptions();
options.PlatformName = "Android";
options.AutomationName = "UiAutomator2";
using var driver = new AndroidDriver(new Uri(endpoint), options);
try
{
// ... your test ...
}
finally
{
driver.Quit();
}
}
}
```
------
#### [ Ruby ]
Once your session is up and running, the Appium endpoint URL will be available via a field named `remoteDriverEndpoint` in the response to a call to the [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html) API:
```
# To get the URL
require 'aws-sdk-devicefarm'
def get_appium_endpoint
session_arn = "arn:aws:devicefarm:us-west-2:111122223333:session:abcdef123456-1234-5678-abcd-abcdef123456/abcdef123456-1234-5678-abcd-abcdef123456/00000"
client = Aws::DeviceFarm::Client.new(region: 'us-west-2')
resp = client.get_remote_access_session(arn: session_arn)
endpoint = resp.remote_access_session.endpoints.remote_driver_endpoint
raise "remote_driver_endpoint missing from response" if endpoint.nil? || endpoint.empty?
endpoint
end
# To use the URL
require 'appium_lib_core'
endpoint = get_appium_endpoint
opts = {
server_url: endpoint,
capabilities: {
'platformName' => 'Android',
'appium:automationName' => 'UiAutomator2'
}
}
driver = Appium::Core.for(opts).start_driver
begin
# ... your test ...
ensure
driver.quit
end
```
------
# Reviewing your Appium server logs
Once you've [started an Appium session](appium-endpoint-interaction.md), you can view the Appium server logs live in the Device Farm console, or download them after the remote access session ends. Here are the instructions for doing so:
------
#### [ Console ]
1. In the Device Farm console, open the Remote access session for your device.
1. Start an Appium endpoint session with the device from your local IDE or Appium Inspector
1. Then, the Appium server log will appear alongside the device in the remote access session page, with the "session information" available at the bottom of the page below the device:
![\[\]](http://docs.aws.amazon.com/devicefarm/latest/developerguide/images/aws-device-farm-appium-endpoint-logs.gif)
------
#### [ AWS CLI ]
*Note: this example uses the [command-line tool `curl`](https://curl.se/) to pull the log from Device Farm.*
During or after the session, you can use Device Farm's [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html) API to download the Appium server log.
```
$ aws devicefarm list-artifacts \
--type FILE \
--arn arn:aws:devicefarm:us-west-2:111122223333:session:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcdef/00000
```
This will show output such as the following during the session:
```
{
"artifacts": [
{
"arn": "arn:aws:devicefarm:us-west-2:111122223333:artifact:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcdef/00000",
"name": "AppiumServerLogOutput",
"type": "APPIUM_SERVER_LOG_OUTPUT",
"extension": "",
"url": "https://prod-us-west-2-results.s3.dualstack.us-west-2.amazonaws.com/111122223333/12345678..."
}
]
}
```
And the following after the session is done:
```
{
"artifacts": [
{
"arn": "arn:aws:devicefarm:us-west-2:111122223333:artifact:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcdef/00000",
"name": "Appium Server Output",
"type": "APPIUM_SERVER_OUTPUT",
"extension": "log",
"url": "https://prod-us-west-2-results.s3.dualstack.us-west-2.amazonaws.com/111122223333/12345678..."
}
]
}
```
```
$ curl "https://prod-us-west-2-results.s3.dualstack.us-west-2.amazonaws.com/111122223333/12345678..."
```
This will show output such as the following:
```
info Appium Welcome to Appium v2.5.4
info Appium Non-default server args:
info Appium { address: '127.0.0.1',
info Appium allowInsecure:
info Appium [ 'execute_driver_script',
info Appium 'session_discovery',
info Appium 'perf_record',
info Appium 'adb_shell',
info Appium 'chromedriver_autodownload',
info Appium 'get_server_logs' ],
info Appium keepAliveTimeout: 0,
info Appium logNoColors: true,
info Appium logTimestamp: true,
info Appium longStacktrace: true,
info Appium sessionOverride: true,
info Appium strictCaps: true,
info Appium useDrivers: [ 'uiautomator' ] }
```
------
#### [ Python ]
*Note: this example uses the third-party `requests` package to download the log, as well as the AWS SDK for Python `boto3`.*
During or after the session, you can use Device Farm's [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html) API to retrieve the Appium server log URL, then download it.
```
import pathlib
import requests
import boto3
def download_appium_log():
session_arn = "arn:aws:devicefarm:us-west-2:111122223333:session:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcdef/00000"
client = boto3.client("devicefarm", region_name="us-west-2")
# 1) List artifacts for the session (FILE artifacts), handling pagination
artifacts = []
token = None
while True:
kwargs = {"arn": session_arn, "type": "FILE"}
if token:
kwargs["nextToken"] = token
resp = client.list_artifacts(**kwargs)
artifacts.extend(resp.get("artifacts", []))
token = resp.get("nextToken")
if not token:
break
if not artifacts:
raise RuntimeError("No artifacts found in this session")
# Filter strictly to Appium server logs
allowed = {"APPIUM_SERVER_OUTPUT", "APPIUM_SERVER_LOG_OUTPUT"}
filtered = [a for a in artifacts if a.get("type") in allowed]
if not filtered:
raise RuntimeError("No Appium server log artifacts found (expected APPIUM_SERVER_OUTPUT or APPIUM_SERVER_LOG_OUTPUT)")
# Prefer the final 'OUTPUT' log, else the live 'LOG_OUTPUT'
chosen = (next((a for a in filtered if a.get("type") == "APPIUM_SERVER_OUTPUT"), None)
or next((a for a in filtered if a.get("type") == "APPIUM_SERVER_LOG_OUTPUT"), None))
url = chosen["url"]
ext = chosen.get("extension") or "log"
out = pathlib.Path(f"./appium_server_log.{ext}")
# 2) Download the artifact
with requests.get(url, stream=True) as r:
r.raise_for_status()
with open(out, "wb") as fh:
for chunk in r.iter_content(chunk_size=1024 * 1024):
if chunk:
fh.write(chunk)
print(f"Saved Appium server log to: {out.resolve()}")
download_appium_log()
```
This will show output such as the following:
```
info Appium Welcome to Appium v2.5.4
info Appium Non-default server args:
info Appium { address: '127.0.0.1', allowInsecure: [ 'execute_driver_script', ... ], useDrivers: [ 'uiautomator' ] }
```
------
#### [ Java ]
*Note: this example uses the AWS SDK for Java v2 and `HttpClient` to download the log, and is compatible with JDK versions 11 and higher.*
During or after the session, you can use Device Farm's [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html) API to retrieve the Appium server log URL, then download it.
```
import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Path;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.devicefarm.DeviceFarmClient;
import software.amazon.awssdk.services.devicefarm.model.Artifact;
import software.amazon.awssdk.services.devicefarm.model.ArtifactCategory;
import software.amazon.awssdk.services.devicefarm.model.ListArtifactsRequest;
import software.amazon.awssdk.services.devicefarm.model.ListArtifactsResponse;
public class AppiumLogDownloader {
public static void main(String[] args) throws Exception {
String sessionArn = "arn:aws:devicefarm:us-west-2:111122223333:session:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcdef/00000";
try (DeviceFarmClient client = DeviceFarmClient.builder()
.region(Region.US_WEST_2)
.build()) {
// 1) List artifacts for the session (FILE artifacts) with pagination
List all = new ArrayList<>();
String token = null;
do {
ListArtifactsRequest.Builder b = ListArtifactsRequest.builder()
.arn(sessionArn)
.type(ArtifactCategory.FILE);
if (token != null) b.nextToken(token);
ListArtifactsResponse page = client.listArtifacts(b.build());
all.addAll(page.artifacts());
token = page.nextToken();
} while (token != null && !token.isBlank());
// Filter strictly to Appium logs
List filtered = all.stream()
.filter(a -> {
String t = a.typeAsString();
return "APPIUM_SERVER_OUTPUT".equals(t) || "APPIUM_SERVER_LOG_OUTPUT".equals(t);
})
.toList();
if (filtered.isEmpty()) {
throw new RuntimeException("No Appium server log artifacts found (expected APPIUM_SERVER_OUTPUT or APPIUM_SERVER_LOG_OUTPUT).");
}
// Prefer OUTPUT; else LOG_OUTPUT
Artifact chosen = filtered.stream()
.filter(a -> "APPIUM_SERVER_OUTPUT".equals(a.typeAsString()))
.findFirst()
.orElseGet(() -> filtered.stream()
.filter(a -> "APPIUM_SERVER_LOG_OUTPUT".equals(a.typeAsString()))
.findFirst()
.get());
String url = chosen.url();
String ext = (chosen.extension() == null || chosen.extension().isBlank()) ? "log" : chosen.extension();
Path out = Path.of("appium_server_log." + ext);
// 2) Download the artifact with HttpClient
HttpClient http = HttpClient.newBuilder()
.connectTimeout(Duration.ofSeconds(10))
.build();
HttpRequest get = HttpRequest.newBuilder(URI.create(url))
.timeout(Duration.ofMinutes(5))
.GET()
.build();
HttpResponse resp = http.send(get, HttpResponse.BodyHandlers.ofFile(out));
if (resp.statusCode() / 100 != 2) {
throw new IOException("Failed to download log, HTTP " + resp.statusCode());
}
System.out.println("Saved Appium server log to: " + out.toAbsolutePath());
}
}
}
```
This will show output such as the following:
```
info Appium Welcome to Appium v2.5.4
info Appium Non-default server args:
info Appium { address: '127.0.0.1', ..., useDrivers: [ 'uiautomator' ] }
```
------
#### [ JavaScript ]
*Note: this example uses AWS SDK for JavaScript (v3) and Node 18\$1 `fetch` to download the log.*
During or after the session, you can use Device Farm's [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html) API to retrieve the Appium server log URL, then download it.
```
import { DeviceFarmClient, ListArtifactsCommand } from "@aws-sdk/client-device-farm";
import { createWriteStream } from "fs";
import { pipeline } from "stream";
import { promisify } from "util";
const pipe = promisify(pipeline);
const client = new DeviceFarmClient({ region: "us-west-2" });
const sessionArn = "arn:aws:devicefarm:us-west-2:111122223333:session:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcdef/00000";
// 1) List artifacts for the session (FILE artifacts), handling pagination
const artifacts = [];
let nextToken;
do {
const page = await client.send(new ListArtifactsCommand({
arn: sessionArn,
type: "FILE",
nextToken
}));
artifacts.push(...(page.artifacts ?? []));
nextToken = page.nextToken;
} while (nextToken);
if (!artifacts.length) throw new Error("No artifacts found");
// Strict filter to Appium logs
const filtered = (artifacts ?? []).filter(a =>
a.type === "APPIUM_SERVER_OUTPUT" || a.type === "APPIUM_SERVER_LOG_OUTPUT"
);
if (!filtered.length) {
throw new Error("No Appium server log artifacts found (expected APPIUM_SERVER_OUTPUT or APPIUM_SERVER_LOG_OUTPUT).");
}
// Prefer OUTPUT; else LOG_OUTPUT
const chosen =
filtered.find(a => a.type === "APPIUM_SERVER_OUTPUT") ??
filtered.find(a => a.type === "APPIUM_SERVER_LOG_OUTPUT");
const url = chosen.url;
const ext = chosen.extension || "log";
const outPath = `./appium_server_log.${ext}`;
// 2) Download the artifact
const resp = await fetch(url);
if (!resp.ok) {
throw new Error(`Failed to download log: ${resp.status} ${await resp.text().catch(()=>"")}`);
}
await pipe(resp.body, createWriteStream(outPath));
console.log("Saved Appium server log to:", outPath);
```
This will show output such as the following:
```
info Appium Welcome to Appium v2.5.4
info Appium Non-default server args:
info Appium { address: '127.0.0.1', allowInsecure: [ 'execute_driver_script', ... ], useDrivers: [ 'uiautomator' ] }
```
------
#### [ C\$1 ]
*Note: this example uses the AWS SDK for .NET and `HttpClient` to download the log.*
During or after the session, you can use Device Farm's [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html) API to retrieve the Appium server log URL, then download it.
```
using System;
using System.Collections.Generic;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;
using System.Linq;
using Amazon;
using Amazon.DeviceFarm;
using Amazon.DeviceFarm.Model;
class AppiumLogDownloader
{
static async Task Main()
{
var sessionArn = "arn:aws:devicefarm:us-west-2:111122223333:session:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcdef/00000";
using var client = new AmazonDeviceFarmClient(RegionEndpoint.USWest2);
// 1) List artifacts for the session (FILE artifacts), handling pagination
var all = new List();
string? token = null;
do
{
var page = await client.ListArtifactsAsync(new ListArtifactsRequest
{
Arn = sessionArn,
Type = ArtifactCategory.FILE,
NextToken = token
});
if (page.Artifacts != null) all.AddRange(page.Artifacts);
token = page.NextToken;
} while (!string.IsNullOrEmpty(token));
if (all.Count == 0)
throw new Exception("No artifacts found");
// Strict filter to Appium logs
var filtered = all.Where(a =>
a.Type == "APPIUM_SERVER_OUTPUT" || a.Type == "APPIUM_SERVER_LOG_OUTPUT").ToList();
if (filtered.Count == 0)
throw new Exception("No Appium server log artifacts found (expected APPIUM_SERVER_OUTPUT or APPIUM_SERVER_LOG_OUTPUT).");
// Prefer OUTPUT; else LOG_OUTPUT
var chosen = filtered.FirstOrDefault(a => a.Type == "APPIUM_SERVER_OUTPUT")
?? filtered.First(a => a.Type == "APPIUM_SERVER_LOG_OUTPUT");
var url = chosen.Url;
var ext = string.IsNullOrWhiteSpace(chosen.Extension) ? "log" : chosen.Extension;
var outPath = $"./appium_server_log.{ext}";
// 2) Download the artifact
using var http = new HttpClient();
using var resp = await http.GetAsync(url, HttpCompletionOption.ResponseHeadersRead);
resp.EnsureSuccessStatusCode();
await using (var fs = File.Create(outPath))
{
await resp.Content.CopyToAsync(fs);
}
Console.WriteLine($"Saved Appium server log to: {Path.GetFullPath(outPath)}");
}
}
```
This will show output such as the following:
```
info Appium Welcome to Appium v2.5.4
info Appium Non-default server args:
info Appium { address: '127.0.0.1', ..., useDrivers: [ 'uiautomator' ] }
```
------
#### [ Ruby ]
*Note: this example uses the AWS SDK for Ruby and `Net::HTTP` to download the log.*
During or after the session, you can use Device Farm's [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html) API to retrieve the Appium server log URL, then download it.
```
require "aws-sdk-devicefarm"
require "net/http"
require "uri"
client = Aws::DeviceFarm::Client.new(region: "us-west-2")
session_arn = "arn:aws:devicefarm:us-west-2:111122223333:session:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcdef/00000"
# 1) List artifacts for the session (FILE artifacts), handling pagination
artifacts = []
token = nil
loop do
page = client.list_artifacts(arn: session_arn, type: "FILE", next_token: token)
artifacts.concat(page.artifacts || [])
token = page.next_token
break if token.nil? || token.empty?
end
raise "No artifacts found" if artifacts.empty?
# Strict filter to Appium logs
filtered = (artifacts || []).select { |a| ["APPIUM_SERVER_OUTPUT", "APPIUM_SERVER_LOG_OUTPUT"].include?(a.type) }
raise "No Appium server log artifacts found (expected APPIUM_SERVER_OUTPUT or APPIUM_SERVER_LOG_OUTPUT)." if filtered.empty?
# Prefer OUTPUT; else LOG_OUTPUT
chosen = filtered.find { |a| a.type == "APPIUM_SERVER_OUTPUT" } ||
filtered.find { |a| a.type == "APPIUM_SERVER_LOG_OUTPUT" }
url = chosen.url
ext = (chosen.extension && !chosen.extension.empty?) ? chosen.extension : "log"
out_path = "./appium_server_log.#{ext}"
# 2) Download the artifact
uri = URI.parse(url)
Net::HTTP.start(uri.host, uri.port, use_ssl: (uri.scheme == "https")) do |http|
req = Net::HTTP::Get.new(uri)
http.request(req) do |resp|
raise "Failed GET: #{resp.code} #{resp.body}" unless resp.code.to_i / 100 == 2
File.open(out_path, "wb") { |f| resp.read_body { |chunk| f.write(chunk) } }
end
end
puts "Saved Appium server log to: #{File.expand_path(out_path)}"
```
This will show output such as the following:
```
info Appium Welcome to Appium v2.5.4
info Appium Non-default server args:
info Appium { address: '127.0.0.1', allowInsecure: [ 'execute_driver_script', ... ], useDrivers: [ 'uiautomator' ] }
```
------
# Supported Appium capabilities and commands
Device Farm's Appium endpoint supports most of the same commands and desired capabilities that you use on local devices, with a few exceptions. The following lists show which capabilities and commands are currently not supported. If your tests are unable to run as expected due to a restricted capability, please open a support case for additional guidance.
## Supported capabilities
When creating an Appium session on Device Farm, we recommend having a distinct set of capabilities which exclude any capabilities specific to your local device. On Device Farm, session creation may fail if certain unsupported capabilities are set. This includes device-specific capabilities like `udid` and `platformVersion`. Additionally, certain capabilities related to ChromeDriver on Android and WebDriverAgent on iOS aren't supported, as well as capabilities that are only supported on emulators and simulators.
## Supported commands
Most Appium commands that run properly on real Android and iOS devices will run as-expected on Device Farm, with the following exclusions:
### Appium device commands (`/appium/device`)
+ `install_app`
+ `finger_print`
+ `send_sms`
+ `gsm_call`
+ `gsm_signal`
+ `gsm_voice`
+ `power_ac`
+ `power_capacity`
+ `network_speed`
+ `shake`
### Appium execute methods and scripts (`/execute`)
+ `installApp`
+ `execEmuConsoleCommand`
+ `fingerprint`
+ `gsmCall`
+ `gsmSignal`
+ `sendSms`
+ `gsmVoice`
+ `powerAC`
+ `powerCapacity`
+ `networkSpeed`
+ `sensorSet`
+ `injectEmulatorCameraImage`
+ `isGpsEnabled`
+ `shake`
+ `clearApp`
+ `clearKeychains`
+ `configureLocalization`
+ `enrollBiometric`
+ `getPasteboard`
+ `installXCTestBundle`
+ `listXCTestBundles`
+ `listXCTestsInTestBundle`
+ `runXCTest`
+ `sendBiometricMatch`
+ `setPasteboard`
+ `setPermission`
+ `startAudioRecording`
+ `startLogsBroadcast`
+ `startRecordingScreen`
+ `startScreenStreaming`
+ `startXCTestScreenRecording`
+ `stopAudioRecording`
+ `stopLogsBroadcast`
+ `stopRecordingScreen`
+ `stopScreenStreaming`
+ `stopXCTestScreenRecording`
+ `updateSafariPreferences`