Features
Start a free trial

Automated Test Options

Below are various options you can use for your Automated Testing.

The Selenium-Specific Settings are required to run Automated Tests and are called Desired Capabilities.

The TestingBot Options allow you to customize your test in terms of specific driver versions, privacy options, platform options, ...

Required Selenium Settings

Browser Name

The name of the browser to run your automated test on. Please see our list of browsers that we support.

The browserName is a required field that needs to be passed to us via Selenium's Desired Capabilities.

Copy code
caps = Selenium::WebDriver::Remote::Capabilities.new
caps["browserName"] = "chrome"
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("browserName", "chrome");
Copy code
$caps = array(
  "browserName" => "chrome"
);
Copy code
capabilities = {
  "browserName" : "chrome"
}
Copy code
const capabilities = {
  "browserName" : "chrome"
}
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("browserName", "chrome");
Selenium W3C Example:
Copy code
caps = {
  browserName: "chrome"
}
Copy code
ChromeOptions chromeOpts = new ChromeOptions();
chromeOpts.setExperimentalOption("w3c", true);

MutableCapabilities tbOptions = new MutableCapabilities();
tbOptions.setCapability("key", "api_key");
tbOptions.setCapability("secret", "api_secret");

DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(ChromeOptions.CAPABILITY, chromeOpts);
caps.setCapability("tb:options", tbOptions);
caps.setCapability("browserName", "chrome");
Copy code
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
Copy code
tbOptions = {
	'name': 'W3C Sample'
}

chromeOpts =  {
    'browserName': "chrome",
    'goog:chromeOptions': {'w3c': True},
    'tb:options': tbOptions
}

self.driver = webdriver.Remote(remote_url, desired_capabilities=chromeOpts)
Copy code
driver = await new webdriver.Builder().withCapabilities({
    "browserName": 'chrome',
    /** Google requires "w3c" to be set in "goog:chromeOptions" as true if you're using ChromeDriver version 74 or lower.
     * Based on this commit: https://chromium.googlesource.com/chromium/src/+/2b49880e2481658e0702fd6fe494859bca52b39c
     * ChromeDriver now uses w3c by default from version 75+ so setting this option will no longer be a requirement **/
    "goog:chromeOptions" : { "w3c" : true },
    "tb:options": {
        "key": "api_key",
        "secret": "api_secret"
    }
}).usingServer("https://hub.testingbot.com/wd/hub").build();
Copy code
var chromeOptions = new ChromeOptions()
{
    BrowserVersion = "latest",
    PlatformName = "Windows 10",
    UseSpecCompliantProtocol = true
};
var tbOptions = new Dictionary<string, object>
{
    ["key"] = "api_key",
    ["secret"] = "api_secret",
    ["name"] = TestContext.CurrentContext.Test.Name
};

chromeOptions.AddAdditionalCapability("tb:options", tbOptions, true);

driver = new RemoteWebDriver(new Uri("https://hub.testingbot.com/wd/hub"),
    chromeOptions.ToCapabilities(), TimeSpan.FromSeconds(600));

Browser Version

The version of the browser to run your automated test on. Please see our list of browsers + versions that we support.

The version is a required field that needs to be passed to us via Selenium's Desired Capabilities.

Copy code
caps = Selenium::WebDriver::Remote::Capabilities.new
caps["version"] = "81"
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("version", "81");
Copy code
$caps = array(
  "version" => "81"
);
Copy code
capabilities = {
  "version" : "81"
}
Copy code
const capabilities = {
	 "version" : "81"
}
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("version", "81");
Selenium W3C Example:
Copy code
caps = {
  browserName: "chrome",
  browserVersion: "106"
}
Copy code
ChromeOptions chromeOpts = new ChromeOptions();
chromeOpts.setExperimentalOption("w3c", true);

MutableCapabilities tbOptions = new MutableCapabilities();
tbOptions.setCapability("key", "api_key");
tbOptions.setCapability("secret", "api_secret");

DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(ChromeOptions.CAPABILITY, chromeOpts);
caps.setCapability("browserVersion", "81");
caps.setCapability("tb:options", tbOptions);
caps.setCapability("browserName", "chrome");
Copy code
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setVersion(81);
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
Copy code
tbOptions = {
	'name': 'W3C Sample'
}

chromeOpts =  {
    'browserName': "chrome",
    'browserVersion': '81',
    'goog:chromeOptions': {'w3c': True},
    'tb:options': tbOptions
}

self.driver = webdriver.Remote(remote_url, desired_capabilities=chromeOpts)
Copy code
driver = await new webdriver.Builder().withCapabilities({
    "browserName": 'chrome',
    "browserVersion": "81",
    /** Google requires "w3c" to be set in "goog:chromeOptions" as true if you're using ChromeDriver version 74 or lower.
     * Based on this commit: https://chromium.googlesource.com/chromium/src/+/2b49880e2481658e0702fd6fe494859bca52b39c
     * ChromeDriver now uses w3c by default from version 75+ so setting this option will no longer be a requirement **/
    "goog:chromeOptions" : { "w3c" : true },
    "tb:options": {
        "key": "api_key",
        "secret": "api_secret"
    }
}).usingServer("https://hub.testingbot.com/wd/hub").build();
Copy code
var chromeOptions = new ChromeOptions()
{
    BrowserVersion = "81",
    PlatformName = "Windows 10",
    UseSpecCompliantProtocol = true
};
var tbOptions = new Dictionary<string, object>
{
    ["key"] = "api_key",
    ["secret"] = "api_secret",
    ["name"] = TestContext.CurrentContext.Test.Name
};

chromeOptions.AddAdditionalCapability("tb:options", tbOptions, true);

driver = new RemoteWebDriver(new Uri("https://hub.testingbot.com/wd/hub"),
    chromeOptions.ToCapabilities(), TimeSpan.FromSeconds(600));
Other Options:
  • "version": "*" : If you use * as version, TestingBot will pick a random version.
  • "version": "latest" : TestingBot will automatically take the latest version. You can also use latest-1, latest-2, ... to test on the next most recent versions. For example, if the current latest Firefox version is 81 and you use latest-2, then the test will run on Firefox 79.

  • "version": "<=16" : TestingBot will pick a version smaller than or equal to the version you specify with <=.
    "version": "16>=" : TestingBot will pick a version higher than or equal to the version you specify with >=.

Platform

Indicates on which operating system the test should run. Please see a list of platforms that we currently support.

The platform is a required field that needs to be passed to us via Selenium's Desired Capabilities.

Copy code
caps = Selenium::WebDriver::Remote::Capabilities.new
caps["platform"] = "Windows 10"
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("platform", "Windows 10");
Copy code
$caps = array(
  "platform" => "Windows 10"
);
Copy code
capabilities = {
  "platform" : "Windows 10"
}
Copy code
const capabilities = {
	 "platform" : "Windows 10"
}
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("platform", "Windows 10");
Selenium W3C Example:
Copy code
caps = {
  platform_name: "Windows 10"	
}
Copy code
ChromeOptions chromeOpts = new ChromeOptions();
chromeOpts.setExperimentalOption("w3c", true);

MutableCapabilities tbOptions = new MutableCapabilities();
tbOptions.setCapability("key", "api_key");
tbOptions.setCapability("secret", "api_secret");

DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(ChromeOptions.CAPABILITY, chromeOpts);
caps.setCapability("platformName", "Windows 10");
caps.setCapability("tb:options", tbOptions);
caps.setCapability("browserName", "chrome");
Copy code
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
Copy code
tbOptions = {
	'name': 'W3C Sample'
}

chromeOpts =  {
    'browserName': "chrome",
    'platformName': "Windows 10",
    'goog:chromeOptions': {'w3c': True},
    'tb:options': tbOptions
}

self.driver = webdriver.Remote(remote_url, desired_capabilities=chromeOpts)
Copy code
driver = await new webdriver.Builder().withCapabilities({
    "browserName": 'chrome',
    "platformName": 'Windows 10',
    /** Google requires "w3c" to be set in "goog:chromeOptions" as true if you're using ChromeDriver version 74 or lower.
     * Based on this commit: https://chromium.googlesource.com/chromium/src/+/2b49880e2481658e0702fd6fe494859bca52b39c
     * ChromeDriver now uses w3c by default from version 75+ so setting this option will no longer be a requirement **/
    "goog:chromeOptions" : { "w3c" : true },
    "tb:options": {
        "key": "api_key",
        "secret": "api_secret"
    }
}).usingServer("https://hub.testingbot.com/wd/hub").build();
Copy code
var chromeOptions = new ChromeOptions()
{
    BrowserVersion = "81",
    PlatformName = "Windows 10",
    UseSpecCompliantProtocol = true
};
var tbOptions = new Dictionary<string, object>
{
    ["key"] = "api_key",
    ["secret"] = "api_secret",
    ["name"] = TestContext.CurrentContext.Test.Name
};

chromeOptions.AddAdditionalCapability("tb:options", tbOptions, true);

driver = new RemoteWebDriver(new Uri("https://hub.testingbot.com/wd/hub"),
    chromeOptions.ToCapabilities(), TimeSpan.FromSeconds(600));

Device Name

When running a mobile automated test, you'll need to specify on which mobile device (or simulator/emulator) you want to test.

Copy code
caps = {
  deviceName: "Samsung S21"	
}
Copy code
ChromeOptions chromeOpts = new ChromeOptions();
chromeOpts.setExperimentalOption("w3c", true);

MutableCapabilities tbOptions = new MutableCapabilities();
tbOptions.setCapability("key", "api_key");
tbOptions.setCapability("secret", "api_secret");

DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(ChromeOptions.CAPABILITY, chromeOpts);
caps.setCapability("platformName", "Android");
caps.setCapability("tb:options", tbOptions);
caps.setCapability("appium:deviceName", "Samsung S23");
Copy code
tbOptions = {
	'name': 'W3C Sample'
}

chromeOpts =  {
    'deviceName': "Samsung S21",
    'platformName': "Android",
    'goog:chromeOptions': {'w3c': True},
    'tb:options': tbOptions
}

self.driver = webdriver.Remote(remote_url, desired_capabilities=chromeOpts)
Copy code
driver = await new webdriver.Builder().withCapabilities({
    "browserName": 'chrome',
    "appium:deviceName": 'Samsung S23',
    "platformName": 'Android',
    "goog:chromeOptions" : { "w3c" : true },
    "tb:options": {
        "key": "api_key",
        "secret": "api_secret"
    }
}).usingServer("https://hub.testingbot.com/wd/hub").build();
Copy code
var chromeOptions = new ChromeOptions()
{
    PlatformName = "Android",
    UseSpecCompliantProtocol = true
};
var tbOptions = new Dictionary<string, object>
{
    ["key"] = "api_key",
    ["secret"] = "api_secret",
    ["name"] = TestContext.CurrentContext.Test.Name,
    ["appium:deviceName"] = "Samsung S23"
};

chromeOptions.AddAdditionalCapability("tb:options", tbOptions, true);

driver = new RemoteWebDriver(new Uri("https://hub.testingbot.com/wd/hub"),
    chromeOptions.ToCapabilities(), TimeSpan.FromSeconds(600));
Physical Devices Only

We offer special parameters which you can use to allocate a device:

Regex Input Result
"iPhone.*" This will allocate any available iPhone device (phone)
".*Galaxy.*" This will allocate any of the available Galaxy devices (phone or tablet)
"*" This will allocate a random available device, either iOS or Android device
"iPhone [8-11]" This will allocate either an iPhone 8 or 11
"iPhone 6.*" This will allocate either an iPhone 6 or 6S

Some Examples:

Copy code
// find any iPhone, except 6 or 6s
capabilities.setCapability("appium:deviceName", "^(iPhone.*)(?!6|6S)$");

// find any device which name starts with Samsung
capabilities.setCapability("appium:deviceName", "Samsung.*");

Device Version

You can specify the version of the device you want to target. In case of physical devices, you might want to use regex/wildcard patterns to target a broad range of devices. This way your chance of hitting an occupied device during your automated test decreases significantly.

Instead of only targetting a specific iOS or Android device, you can target a wider range of devices.

Copy code
caps = {
  version: "(16|17).*"	
}
Copy code
ChromeOptions chromeOpts = new ChromeOptions();
chromeOpts.setExperimentalOption("w3c", true);

MutableCapabilities tbOptions = new MutableCapabilities();
tbOptions.setCapability("key", "api_key");
tbOptions.setCapability("secret", "api_secret");

DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(ChromeOptions.CAPABILITY, chromeOpts);
caps.setCapability("appium:platformName", "Android");
caps.setCapability("appium:deviceName", "*");
caps.setCapability("tb:options", tbOptions);
caps.setCapability("appium:version", "(13|14).*");
Copy code
tbOptions = {
	'name': 'W3C Sample'
}

chromeOpts =  {
    'appium:deviceName': "*",
    'appium:version': '(13|14).*'
    'platformName': "Android",
    'goog:chromeOptions': {'w3c': True}
}

self.driver = webdriver.Remote(remote_url, desired_capabilities=chromeOpts)
Copy code
driver = await new webdriver.Builder().withCapabilities({
    "browserName": 'chrome',
    "appium:deviceName": '*',
    "appium:version": '(13|14).*',
    "platformName": 'Android',
    "goog:chromeOptions" : { "w3c" : true },
    "tb:options": {
        "key": "api_key",
        "secret": "api_secret"
    }
}).usingServer("https://hub.testingbot.com/wd/hub").build();
Copy code
var chromeOptions = new ChromeOptions()
{
    PlatformName = "Android"
};
var tbOptions = new Dictionary<string, object>
{
    ["key"] = "api_key",
    ["secret"] = "api_secret",
    ["name"] = TestContext.CurrentContext.Test.Name,
    ["deviceName"] = "*"
    ["version"] = "(13|14).*"
};

chromeOptions.AddAdditionalCapability("tb:options", tbOptions, true);

driver = new RemoteWebDriver(new Uri("https://hub.testingbot.com/wd/hub"),
    chromeOptions.ToCapabilities(), TimeSpan.FromSeconds(600));

Some Examples:

Copy code
// target multiple specific versions of an iPhone device
capabilities.setCapability("appium:deviceName", "iPhone.*");
capabilities.setCapability("appium:version", "15.0|14.2|14|13.4|13.3");

// find any Samsung device with Android version 13 or 14
capabilities.setCapability("appium:deviceName", "Samsung.*");
capabilities.setCapability("appium:version", "(13|14).*");

Tablet Only

You can specify this capability when you only want to allocate a tablet device.

Copy code
caps = {
  deviceName: "*",
  tabletOnly: true
}
Copy code
ChromeOptions chromeOpts = new ChromeOptions();
chromeOpts.setExperimentalOption("w3c", true);

MutableCapabilities tbOptions = new MutableCapabilities();
tbOptions.setCapability("key", "api_key");
tbOptions.setCapability("secret", "api_secret");
tbOptions.setCapability("tabletOnly", true);
tbOptions.setCapability("deviceName", "*");

DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(ChromeOptions.CAPABILITY, chromeOpts);
caps.setCapability("platformName", "Android");
caps.setCapability("tb:options", tbOptions);
Copy code
tbOptions = {
	'name': 'W3C Sample'
}

chromeOpts =  {
    'deviceName': "*",
    'tabletOnly': true,
    'platformName': "Android",
    'goog:chromeOptions': {'w3c': True},
    'tb:options': tbOptions
}

self.driver = webdriver.Remote(remote_url, desired_capabilities=chromeOpts)
Copy code
driver = await new webdriver.Builder().withCapabilities({
    "browserName": 'chrome',
    "deviceName": '*',
    "platformName": 'Android',
    "goog:chromeOptions" : { "w3c" : true },
    "tb:options": {
        "key": "api_key",
        "secret": "api_secret",
        "tabletOnly": true
    }
}).usingServer("https://hub.testingbot.com/wd/hub").build();
Copy code
var chromeOptions = new ChromeOptions()
{
    PlatformName = "Android",
    UseSpecCompliantProtocol = true
};
var tbOptions = new Dictionary<string, object>
{
    ["key"] = "api_key",
    ["secret"] = "api_secret",
    ["name"] = TestContext.CurrentContext.Test.Name,
    ["deviceName"] = "*",
    ["tabletOnly"] = true
};

chromeOptions.AddAdditionalCapability("tb:options", tbOptions, true);

driver = new RemoteWebDriver(new Uri("https://hub.testingbot.com/wd/hub"),
    chromeOptions.ToCapabilities(), TimeSpan.FromSeconds(600));

Phone Only

You can specify this capability when you only want to allocate a phone device.

Copy code
caps = {
  deviceName: "*",
  phoneOnly: true
}
Copy code
ChromeOptions chromeOpts = new ChromeOptions();
chromeOpts.setExperimentalOption("w3c", true);

MutableCapabilities tbOptions = new MutableCapabilities();
tbOptions.setCapability("key", "api_key");
tbOptions.setCapability("secret", "api_secret");
tbOptions.setCapability("phoneOnly", true);
tbOptions.setCapability("deviceName", "*");

DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(ChromeOptions.CAPABILITY, chromeOpts);
caps.setCapability("platformName", "Android");
caps.setCapability("tb:options", tbOptions);
Copy code
tbOptions = {
	'name': 'W3C Sample'
}

chromeOpts =  {
    'deviceName': "*",
    'phoneOnly': true,
    'platformName': "Android",
    'goog:chromeOptions': {'w3c': True},
    'tb:options': tbOptions
}

self.driver = webdriver.Remote(remote_url, desired_capabilities=chromeOpts)
Copy code
driver = await new webdriver.Builder().withCapabilities({
    "browserName": 'chrome',
    "deviceName": '*',
    "platformName": 'Android',
    "goog:chromeOptions" : { "w3c" : true },
    "tb:options": {
        "key": "api_key",
        "secret": "api_secret",
        "phoneOnly": true
    }
}).usingServer("https://hub.testingbot.com/wd/hub").build();
Copy code
var chromeOptions = new ChromeOptions()
{
    PlatformName = "Android",
    UseSpecCompliantProtocol = true
};
var tbOptions = new Dictionary<string, object>
{
    ["key"] = "api_key",
    ["secret"] = "api_secret",
    ["name"] = TestContext.CurrentContext.Test.Name,
    ["deviceName"] = "*",
    ["phoneOnly"] = true
};

chromeOptions.AddAdditionalCapability("tb:options", tbOptions, true);

driver = new RemoteWebDriver(new Uri("https://hub.testingbot.com/wd/hub"),
    chromeOptions.ToCapabilities(), TimeSpan.FromSeconds(600));

Use a specific version of Selenium

By default we use Selenium version 2.53.1 to run your test.
If you wish to use another Selenium version for your test, please specify one of the following available versions:

Copy code
caps = Selenium::WebDriver::Remote::Capabilities.new
caps["selenium-version"] = '2.53.1'
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("selenium-version", '2.53.1');
Copy code
$caps = array(
  "selenium-version" => '2.53.1'
);
Copy code
capabilities = {
  "selenium-version" : '2.53.1'
}
Copy code
const capabilities = {
  "selenium-version" : '2.53.1'
}
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("selenium-version", '2.53.1');
Selenium W3C Example:
Copy code
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "selenium-version" : '2.53.1'
  }
}
Copy code
ChromeOptions chromeOpts = new ChromeOptions();
chromeOpts.setExperimentalOption("w3c", true);

MutableCapabilities tbOptions = new MutableCapabilities();
tbOptions.setCapability("key", "api_key");
tbOptions.setCapability("secret", "api_secret");
tbOptions.setCapability("selenium-version", '2.53.1');

DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(ChromeOptions.CAPABILITY, chromeOpts);
caps.setCapability("platformName", "Windows 10");
caps.setCapability("tb:options", tbOptions);
caps.setCapability("browserName", "chrome");
Copy code
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'selenium-version' => '2.53.1'
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
Copy code
tbOptions = {
	'name': 'W3C Sample',
	'selenium-version': '2.53.1'
}

chromeOpts =  {
    'browserName': "chrome",
    'platformName': "Windows 10",
    'goog:chromeOptions': {'w3c': True},
    'tb:options': tbOptions
}

self.driver = webdriver.Remote(remote_url, desired_capabilities=chromeOpts)
Copy code
driver = await new webdriver.Builder().withCapabilities({
    "browserName": 'chrome',
    "platformName": 'Windows 10',
    /** Google requires "w3c" to be set in "goog:chromeOptions" as true if you're using ChromeDriver version 74 or lower.
     * Based on this commit: https://chromium.googlesource.com/chromium/src/+/2b49880e2481658e0702fd6fe494859bca52b39c
     * ChromeDriver now uses w3c by default from version 75+ so setting this option will no longer be a requirement **/
    "goog:chromeOptions" : { "w3c" : true },
    "tb:options": {
        "key": "api_key",
        "secret": "api_secret",
        "selenium-version": '2.53.1'
    }
}).usingServer("https://hub.testingbot.com/wd/hub").build();
Copy code
var chromeOptions = new ChromeOptions()
{
    BrowserVersion = "81",
    PlatformName = "Windows 10",
    UseSpecCompliantProtocol = true
};
var tbOptions = new Dictionary<string, object>
{
    ["key"] = "api_key",
    ["secret"] = "api_secret",
    ["selenium-version"] = "2.53.1"
};

chromeOptions.AddAdditionalCapability("tb:options", tbOptions, true);

driver = new RemoteWebDriver(new Uri("https://hub.testingbot.com/wd/hub"),
    chromeOptions.ToCapabilities(), TimeSpan.FromSeconds(600));
Value Type Default Value Possible Values:
string "2.53.1"
4.27.0 4.26.0 4.25.0 4.24.0 4.23.1
4.23.0 4.22.0 4.21.0 4.20.0 4.19.0
4.18.1 4.18.0 4.17.0 4.16.1 4.16.0
4.15.0 4.14.1 4.14.0 4.13.0 4.12.1
4.12.0 4.11.0 4.10.0 4.9.0 4.8.3
4.8.2 4.8.1 4.8.0 4.7.0 4.6.0
4.5.3 4.5.2 4.5.1 4.5.0 4.4.0
4.3.0 4.2.2 4.2.1 4.2.0 4.1.3
4.1.2 4.1.1 4.1.0 4.0.0 4.0.0-beta-4
4.0.0-beta-3 4.0.0-beta-2 4.0.0-beta-1 4.0.0-alpha-7 4.0.0-alpha-6
3.141.59 3.141.5 3.141.0 3.14.0 3.13.0
3.12.0 3.11.0 3.10.0 3.9.0 3.8.1
3.8.0 3.7.1 3.7.0 3.6.0 3.5.3
3.5.2 3.5.1 3.5.0 3.4.0 3.3.1
3.3.0 3.2.0 3.1.0 3.0.1 2.53.1
2.53.0 2.52.0 2.51.0 2.50.0 2.49.0
2.48.2 2.48.1 2.48.0

Chromedriver

We support using custom ChromeDriver versions during your tests. By default the most recent Chromedriver is used according to the version of Chrome you're testing on.

If you are looking to download Chromedriver for local testing, please see this url to download chromedriver.

Copy code
caps = Selenium::WebDriver::Remote::Capabilities.new
caps["chromedriverVersion"] = "76.0.3809.25"
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("chromedriverVersion", "76.0.3809.25");
Copy code
$caps = array(
  "chromedriverVersion" => "76.0.3809.25"
);
Copy code
capabilities = {
  "chromedriverVersion" : "76.0.3809.25"
}
Copy code
const capabilities = {
  "chromedriverVersion" : "76.0.3809.25"
}
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("chromedriverVersion", "76.0.3809.25");
Selenium W3C Example:
Copy code
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "chromedriverVersion" : "76.0.3809.25"
  }
}
Copy code
ChromeOptions chromeOpts = new ChromeOptions();
chromeOpts.setExperimentalOption("w3c", true);

MutableCapabilities tbOptions = new MutableCapabilities();
tbOptions.setCapability("key", "api_key");
tbOptions.setCapability("secret", "api_secret");
tbOptions.setCapability("chromedriverVersion", "76.0.3809.25");

DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(ChromeOptions.CAPABILITY, chromeOpts);
caps.setCapability("platformName", "Windows 10");
caps.setCapability("tb:options", tbOptions);
caps.setCapability("browserName", "chrome");
Copy code
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'chromedriverVersion' => "76.0.3809.25"
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
Copy code
tbOptions = {
	'name': 'W3C Sample',
	'chromedriverVersion': "76.0.3809.25"
}

chromeOpts =  {
    'browserName': "chrome",
    'platformName': "Windows 10",
    'goog:chromeOptions': {'w3c': True},
    'tb:options': tbOptions
}

self.driver = webdriver.Remote(remote_url, desired_capabilities=chromeOpts)
Copy code
driver = await new webdriver.Builder().withCapabilities({
    "browserName": 'chrome',
    "platformName": 'Windows 10',
    /** Google requires "w3c" to be set in "goog:chromeOptions" as true if you're using ChromeDriver version 74 or lower.
     * Based on this commit: https://chromium.googlesource.com/chromium/src/+/2b49880e2481658e0702fd6fe494859bca52b39c
     * ChromeDriver now uses w3c by default from version 75+ so setting this option will no longer be a requirement **/
    "goog:chromeOptions" : { "w3c" : true },
    "tb:options": {
        "key": "api_key",
        "secret": "api_secret",
        "chromedriverVersion": "76.0.3809.25"
    }
}).usingServer("https://hub.testingbot.com/wd/hub").build();
Copy code
var chromeOptions = new ChromeOptions()
{
    BrowserVersion = "81",
    PlatformName = "Windows 10"
};
var tbOptions = new Dictionary<string, object>
{
    ["key"] = "api_key",
    ["secret"] = "api_secret",
    ["chromedriverVersion"] = "76.0.3809.25"
};

chromeOptions.AddAdditionalCapability("tb:options", tbOptions, true);

driver = new RemoteWebDriver(new Uri("https://hub.testingbot.com/wd/hub"),
    chromeOptions.ToCapabilities(), TimeSpan.FromSeconds(600));
Value Type Default Value Possible Values:
string "2.46"
dev 132.0.6811.2 131.0.6778.3 130.0.6669.2 129.0.6614.3
128.0.6613.18 127.0.6533.88 127.0.6485.0 126.0.6423.2 125.0.6422.4
124.0.6367.60 124.0.6356.2 123.0.6262.5 122.0.6253.3 121.0.6154.0
121.0.6129.0 120.0.6099.5 119.0.6045.9 118.0.5979.0 117.0.5938.0
116.0.5845.82 115.0.5790.170 115.0.5790.90 114.0.5735.90 114.0.5735.16
113.0.5672.63 113.0.5672.24 112.0.5615.49 112.0.5615.28 111.0.5563.64
111.0.5563.41 111.0.5563.19 110.0.5481.77 110.0.5481.30 109.0.5414.74
109.0.5414.25 108.0.5359.71 108.0.5359.22 107.0.5304.62 107.0.5304.18
106.0.5249.61 106.0.5249.21 105.0.5195.52 105.0.5195.19 104.0.5112.79
104.0.5112.29 104.0.5112.20 103.0.5060.134 103.0.5060.24 102.0.5005.61
102.0.5005.27 101.0.4951.41 101.0.4951.15 100.0.4896.60 100.0.4896.20
99.0.4844.51 99.0.4844.35 99.0.4844.17 98.0.4758.80 98.0.4758.48
97.0.4692.71 97.0.4692.36 97.0.4692.20 96.0.4664.45 95.0.4638.10
94.0.4606.41 93.0.4577.15 92.0.4515.43 91.0.4472.101 91.0.4472.19
90.0.4430.24 89.0.4389.23 88.0.4324.96 88.0.4324.27 87.0.4280.88
87.0.4280.20 86.0.4240.22 85.0.4183.87 85.0.4183.83 85.0.4183.38
84.0.4147.30 83.0.4103.39 83.0.4103.14 81.0.4044.69 81.0.4044.20
80.0.3987.16 79.0.3945.36 79.0.3945.16 78.0.3904.70 78.0.3904.11
77.0.3865.40 77.0.3865.10 76.0.3809.68 76.0.3809.25 76.0.3809.12
75.0.3770.140 75.0.3770.90 75.0.3770.8 74.0.3729.6 73.0.3683.68
73.0.3683.20 72.0.3626.7 72.0.3626.69 71.0.3578.80 71.0.3578.33
71.0.3578.30 71.0.3578.137 70.0.3538.97 70.0.3538.67 70.0.3538.16
2.46 2.45 2.44 2.43 2.42
2.41 2.40 2.39 2.38 2.37
2.36 2.35 2.34 2.33 2.32
2.31 2.30 2.29 2.28 2.27
2.26 2.25 2.24 2.23 2.22
2.21 2.20 2.19 2.16 2.15
2.14 2.13 2.12 2.10

Internet Explorer Driver (IEDriver)

We provide both 32-bit and 64-bit versions of the Internet Explorer driver. By default we use the 2.53.1 (32-bit) IEDriver for your tests.
We use 32-bit because of a slow text entry bug with the 64-bit version.

For our screenshots, we use the 64-bit version, because of a screenshot problem with the 32-bit version.

Copy code
caps = Selenium::WebDriver::Remote::Capabilities.new
caps["iedriverVersion"] = "2.53.1"
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("iedriverVersion", "2.53.1");
Copy code
$caps = array(
  "iedriverVersion" => "2.53.1"
);
Copy code
capabilities = {
  "iedriverVersion" : "2.53.1"
}
Copy code
const capabilities = {
  "iedriverVersion" : "2.53.1"
}
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("iedriverVersion", "2.53.1");
Selenium W3C Example:
Copy code
caps = {
  platformName: "Windows 10",
  browserName: "internet explorer",
  browserVersion: "latest",
  "se:ieOptions": {},
  "tb:options": {
    "iedriverVersion" : "4.8.0",
    "selenium-version": "4.8.0"
  }
}
Copy code
InternetExplorerOptions ieOpts = new InternetExplorerOptions();

MutableCapabilities tbOptions = new MutableCapabilities();
tbOptions.setCapability("key", "api_key");
tbOptions.setCapability("secret", "api_secret");
tbOptions.setCapability("iedriverVersion", "4.8.0");
tbOptions.setCapability("selenium-version", "4.8.0");

DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("se:ieOptions", ieOpts);
caps.setCapability("platformName", "Windows 10");
caps.setCapability("tb:options", tbOptions);
caps.setCapability("browserName", "internet explorer");
Copy code
$capabilities = DesiredCapabilities::internetExplorer();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'iedriverVersion' => "4.8.0",
	'selenium-version' => "4.8.0"
));
$capabilities->setCapability('se:ieOptions', []);
Copy code
tbOptions = {
	'name': 'W3C Sample',
	'iedriverVersion': '4.8.0',
	'selenium-version': '4.8.0'
}

ieOpts =  {
    'browserName': "chrome",
    'platformName': "Windows 10",
    'se:ieOptions': {},
    'tb:options': tbOptions
}

self.driver = webdriver.Remote(remote_url, desired_capabilities=ieOpts)
Copy code
driver = await new webdriver.Builder().withCapabilities({
    "browserName": 'internet explorer',
    "platformName": 'Windows 10',
    "se:ieOptions" : {},
    "tb:options": {
        "key": "api_key",
        "secret": "api_secret",
        "iedriverVersion": "4.8.0",
        "selenium-version": "4.8.0"
    }
}).usingServer("https://hub.testingbot.com/wd/hub").build();
Copy code
var ieOptions = new InternetExplorerOptions()
{
    BrowserVersion = "11",
    PlatformName = "Windows 10",
    UseSpecCompliantProtocol = true
};
var tbOptions = new Dictionary<string, object>
{
    ["key"] = "api_key",
    ["secret"] = "api_secret",
    ["iedriverVersion"] = "4.8.0",
    ["selenium-version"] = "4.8.0"
};

ieOptions.AddAdditionalCapability("tb:options", tbOptions, true);

driver = new RemoteWebDriver(new Uri("https://hub.testingbot.com/wd/hub"),
    ieOptions.ToCapabilities(), TimeSpan.FromSeconds(600));
Value Type Default Value Possible Values:
string 2.53.1
x64_4.14.0 4.14.0 x64_4.11.0 4.11.0 x64_4.10.0
4.10.0 x64_4.8.1 4.8.1 x64_4.8.0 4.8.0
x64_4.7.0 4.7.0 x64_4.6.0 4.6.0 x64_4.3.0
4.3.0 x64_4.2.0 4.2.0 x64_4.0.0 4.0.0
x64_3.141.59 3.141.59 x64_3.141.5 3.141.5 x64_3.141.0
3.141.0 x64_3.14.0 3.14.0 x64_3.13.0 3.13.0
x64_3.12.0 3.12.0 x64_3.11.1 3.11.1 x64_3.11.0
3.11.0 x64_3.10.0 3.10.0 x64_3.9.0 3.9.0
x64_3.8.0 3.8.0 x64_3.7.0 3.7.0 x64_3.6.0
3.6.0 x64_3.5.0 3.5.0 x64_3.4.0 3.4.0
x64_3.3.0 3.3.0 x64_3.2.0 3.2.0 x64_3.1.0
3.1.0 x64_2.53.1 2.53.1 x64_2.53.0 2.53.0
x64_2.52.2 2.52.2 x64_2.51.0 2.51.0 x64_2.50.0
2.50.0 x64_2.49.0 2.49.0 x64_2.48.0 2.48.0
x64_2.47.0 2.47.0 x64_2.46.0 2.46.0 x64_2.45.0
2.45.0 x64_2.42.0 2.42.0

Edge Driver (MicrosoftWebDriver)

EdgeDriver is built by Microsoft to automate the Microsoft Edge Browser.
By default, we make sure that the most recent fully-compatible EdgeDriver is used for every test running on the Microsoft Edge Browser.

Copy code
caps = {
	"browserName" : "MicrosoftEdge",
	"platform": "WINDOWS"
}
caps["edgedriverVersion"] = "110"
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("edgedriverVersion", "110");
Copy code
$caps = array(
  "edgedriverVersion" => "110"
);
Copy code
capabilities = {
  "edgedriverVersion" : "110"
}
Copy code
const capabilities = {
  "edgedriverVersion" : "110",
  "ms:edgeOptions": {}
}
Copy code
var edgeOptions = new EdgeOptions()
{
    BrowserVersion = "11",
    PlatformName = "Windows 10",
    UseSpecCompliantProtocol = true
};
var tbOptions = new Dictionary<string, object>
{
    ["key"] = "api_key",
    ["secret"] = "api_secret",
    ["edgeDriverVersion"] = "110",
    ["selenium-version"] = "4.8.0"
};

edgeOptions.AddAdditionalCapability("tb:options", tbOptions, true);

driver = new RemoteWebDriver(new Uri("https://hub.testingbot.com/wd/hub"),
    edgeOptions.ToCapabilities(), TimeSpan.FromSeconds(600));
Selenium W3C Example:
Copy code
caps = {
  platformName: "Windows 10",
  browserName: "microsoftedge",
  browserVersion: "latest",
  "tb:options" => {
    "edgedriverVersion" : "110"
  },
  "ms:edgeOptions": {}
}
Copy code
EdgeOptions edgeOpts = new EdgeOptions();
edgeOpts.setExperimentalOption("w3c", true);

MutableCapabilities tbOptions = new MutableCapabilities();
tbOptions.setCapability("key", "api_key");
tbOptions.setCapability("secret", "api_secret");
tbOptions.setCapability("edgedriverVersion", "110");

DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(EdgeOptions.CAPABILITY, edgeOpts);
caps.setCapability("platformName", "Windows 10");
caps.setCapability("tb:options", tbOptions);
caps.setCapability("browserName", "chrome");
Copy code
$options = new EdgeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'edgedriverVersion' => "110"
));
$capabilities->setCapability('ms:edgeOptions', array());
$capabilities->setCapability(EdgeOptions::CAPABILITY, $options);
Copy code
tbOptions = {
	'name': 'W3C Sample',
	'edgedriverVersion': '110'
}

chromeOpts =  {
    'browserName': "chrome",
    'platformName': "Windows 10",
    'tb:options': tbOptions,
	'ms:edgeOptions': ''
}

self.driver = webdriver.Remote(remote_url, desired_capabilities=chromeOpts)
Copy code
let driver = await new webdriver.Builder().withCapabilities({
    "browserName": 'microsoftedge',
    "platformName": 'Windows 10',
    "ms:edgeOptions" : {},
    "tb:options": {
        "key": "api_key",
        "secret": "api_secret",
        "edgedriverVersion": "110"
    }
}).usingServer("https://hub.testingbot.com/wd/hub").build();
Copy code
var edgeOptions = new EdgeOptions()
{
    BrowserVersion = "latest",
    PlatformName = "Windows 10",
    UseSpecCompliantProtocol = true
};
var tbOptions = new Dictionary<string, object>
{
    ["key"] = "api_key",
    ["secret"] = "api_secret",
    ["edgedriverVersion"] = "110"
};

edgeOptions.AddAdditionalCapability("tb:options", tbOptions, true);

driver = new RemoteWebDriver(new Uri("https://hub.testingbot.com/wd/hub"),
    edgeOptions.ToCapabilities(), TimeSpan.FromSeconds(600));
Value Type Default Value Possible Values:
string 15063
128 127 126 125 124
123 122 121 120 119
118 117 116 115 114
113 112 111 110 109
108 107 106 105 104
103 102 101 100 99
98 97 96 95 94
93 92 91 90 89
88 87 86 85 84
83 81 dev insiders 16299
15063 14393

Firefox Driver (Geckodriver)

For Firefox 47 and up, webdriver tests on Firefox need to use Mozilla's GeckoDriver.
Specify this option to choose which Geckodriver we should use. By default, we use the version that is most compatible with the Firefox version you request.

Copy code
caps = Selenium::WebDriver::Remote::Capabilities.new
caps["geckodriverVersion"] = "0.28.0"
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("geckodriverVersion", "0.28.0");
Copy code
$caps = array(
  "geckodriverVersion" => "0.28.0"
);
Copy code
capabilities = {
  "geckodriverVersion" : "0.28.0"
}
Copy code
const capabilities = {
  "geckodriverVersion" : "0.28.0"
}
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("geckodriverVersion", "0.28.0");
Selenium W3C Example:
Copy code
caps = {
  platformName: "Windows 10",
  browserName: "firefox",
  browserVersion: "latest",
  "tb:options": {
    "geckodriverVersion" : "0.28.0"
  },
  "moz:firefoxOptions": {}
}
Copy code
FirefoxOptions ffOptions = new FirefoxOptions();
ffOptions.setExperimentalOption("w3c", true);

MutableCapabilities tbOptions = new MutableCapabilities();
tbOptions.setCapability("key", "api_key");
tbOptions.setCapability("secret", "api_secret");
tbOptions.setCapability("geckodriverVersion", "0.28.0");

DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(FirefoxOptions.CAPABILITY, ffOptions);
caps.setCapability("platformName", "Windows 10");
caps.setCapability("tb:options", tbOptions);
caps.setCapability("browserName", "firefox");
Copy code
$options = new FirefoxOptions();
$capabilities = DesiredCapabilities::firefox();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'geckodriverVersion' => "0.28.0"
));
$capabilities->setCapability('moz:firefoxOptions', array());
$capabilities->setCapability(FirefoxOptions::CAPABILITY, $options);
Copy code
tbOptions = {
	'name': 'W3C Sample',
	'geckodriverVersion': "0.28.0"
}

chromeOpts =  {
    'browserName': "firefox",
    'platformName': "Windows 10",
    'tb:options': tbOptions,
    'moz:firefoxOptions': {}
}

self.driver = webdriver.Remote(remote_url, desired_capabilities=chromeOpts)
Copy code
driver = await new webdriver.Builder().withCapabilities({
    "browserName": 'firefox',
    "platformName": 'Windows 10',
    "tb:options": {
        "key": "api_key",
        "secret": "api_secret",
        "geckodriverVersion": "0.28.0"
    },
    'moz:firefoxOptions': {}
}).usingServer("https://hub.testingbot.com/wd/hub").build();
Copy code
var ffOptions = new FirefoxOptions()
{
    BrowserVersion = "latest",
    PlatformName = "Windows 10",
    UseSpecCompliantProtocol = true
};
var tbOptions = new Dictionary<string, object>
{
    ["key"] = "api_key",
    ["secret"] = "api_secret",
    ["geckodriverVersion"] = "0.28.0"
};

ffOptions.AddAdditionalCapability("tb:options", tbOptions, true);

driver = new RemoteWebDriver(new Uri("https://hub.testingbot.com/wd/hub"),
    ffOptions.ToCapabilities(), TimeSpan.FromSeconds(600));
Value Type Default Value Possible Values:
string 0.28.0
0.35.0 0.34.0 0.33.0 0.32.2 0.32.1
0.32.0 0.31.0 0.30.0 0.29.1 0.29.0
0.28.0 0.27.0 0.26.0 0.25.0 0.24.0
0.23.0 0.22.0 0.21.0 0.20.1 0.19.1
0.19.0 0.18.0 0.17.0 0.16.1 0.16.0
0.15.0 0.14.0 0.13.0 0.12.0 0.11.0
0.10.0 0.9.0 0.8.0 0.7.1 0.6.2

Opera Driver

Opera uses the Chromium OperaDriver to automate Opera Desktop Browsers.
Specify this option to choose which OperaDriver we should use. By default, we use the version that is most compatible with the Opera version you request.

Copy code
caps = Selenium::WebDriver::Remote::Capabilities.new
caps["operaDriverVersion"] = "90.0.4430.85"
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("operaDriverVersion", "90.0.4430.85");
Copy code
$caps = array(
  "operaDriverVersion" => "90.0.4430.85"
);
Copy code
capabilities = {
  "operaDriverVersion" : "90.0.4430.85"
}
Copy code
const capabilities = {
  "operaDriverVersion" : "90.0.4430.85"
}
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("operaDriverVersion", "90.0.4430.85");
Selenium W3C Example:
Copy code
caps = {
  platformName: "Windows 10",
  browserName: "opera",
  browserVersion: "latest",
  "tb:options" => {
    "operaDriverVersion" : "90.0.4430.85"
  }
}
Copy code
OperaOptions operaOpts = new OperaOptions();

MutableCapabilities tbOptions = new MutableCapabilities();
tbOptions.setCapability("key", "api_key");
tbOptions.setCapability("secret", "api_secret");
tbOptions.setCapability("operaDriverVersion", "90.0.4430.85");

DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(OperaOptions.CAPABILITY, chromeOpts);
caps.setCapability("platformName", "Windows 10");
caps.setCapability("tb:options", tbOptions);
caps.setCapability("browserName", "opera");
Copy code
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setBrowserName('opera');
$capabilities->setCapability('tb:options', array(
	'operaDriverVersion' => "90.0.4430.85"
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
Copy code
tbOptions = {
	'name': 'W3C Sample',
	'operaDriverVersion': "90.0.4430.85"
}

chromeOpts =  {
    'browserName': "opera",
    'platformName': "Windows 10",
    'tb:options': tbOptions
}

self.driver = webdriver.Remote(remote_url, desired_capabilities=chromeOpts)
Copy code
driver = await new webdriver.Builder().withCapabilities({
    "browserName": 'opera',
    "platformName": 'Windows 10',
    "tb:options": {
        "key": "api_key",
        "secret": "api_secret",
        "operaDriverVersion": "90.0.4430.85"
    }
}).usingServer("https://hub.testingbot.com/wd/hub").build();
Copy code
var operaOptions = new OperaOptions()
{
    BrowserVersion = "81",
    PlatformName = "Windows 10",
    UseSpecCompliantProtocol = true
};
var tbOptions = new Dictionary<string, object>
{
    ["key"] = "api_key",
    ["secret"] = "api_secret",
    ["operaDriverVersion"] = "90.0.4430.85"
};

chromeOptions.AddAdditionalCapability("tb:options", tbOptions, true);

driver = new RemoteWebDriver(new Uri("https://hub.testingbot.com/wd/hub"),
    operaOptions.ToCapabilities(), TimeSpan.FromSeconds(600));
Value Type Default Value Possible Values:
string 87.0.4280.67
127.0.6533.120 126.0.6478.127 125.0.6422.143 124.0.6367.62 123.0.6312.59
122.0.6261.95 121.0.6167.140 120.0.6099.200 119.0.6045.124 118.0.5993.89
117.0.5938.132 116.0.5845.97 115.0.5790.171 114.0.5735.110 113.0.5672.127
112.0.5615.87 111.0.5563.65 110.0.5481.100 109.0.5414.120 108.0.5359.99
107.0.5304.88 106.0.5249.119 105.0.5195.102 104.0.5112.81 103.0.5060.66
102.0.5005.61 101.0.4951.64 100.0.4896.127 99.0.4844.51 98.0.4758.82
97.0.4692.71 96.0.4664.45 95.0.4638.54 94.0.4606.61 93.0.4577.63
92.0.4515.107 91.0.4472.77 90.0.4430.85 89.0.4389.82 88.0.4324.104
87.0.4280.67 86.0.4240.80 85.0.4183.102 84.0.4147.89 83.0.4103.97
81.0.4044.113 80.0.3987.100 79.0.3945.79 78.0.3904.87 77.0.3865.120
76.0.3809.132 75.0.3770.100 2.45 2.42 2.41
2.40 2.38 2.37 2.36 2.35
2.33 2.32 2.30 2.229 2.27
2.26 2.25 2.24 2.23 2.22

Taking screenshots during your tests

By default we do not capture screenshots at every step of your test. If you wish to take a screenshot for every step, please add this capability (set to true) to your request.

Copy code
caps = Selenium::WebDriver::Remote::Capabilities.new
caps["screenshot"] = true
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("screenshot", true);
Copy code
$caps = array(
  "screenshot" => true
);
Copy code
capabilities = {
  "screenshot" : True
}
Copy code
const capabilities = {
  "screenshot" : true
}
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("screenshot", true);
Selenium W3C Example:
Copy code
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    screenshot: true
  }
}
Copy code
ChromeOptions chromeOpts = new ChromeOptions();
chromeOpts.setExperimentalOption("w3c", true);

MutableCapabilities tbOptions = new MutableCapabilities();
tbOptions.setCapability("key", "api_key");
tbOptions.setCapability("secret", "api_secret");
tbOptions.setCapability("screenshot", true);

DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(ChromeOptions.CAPABILITY, chromeOpts);
caps.setCapability("platformName", "Windows 10");
caps.setCapability("tb:options", tbOptions);
caps.setCapability("browserName", "chrome");
Copy code
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'screenshot' => true
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
Copy code
tbOptions = {
	'name': 'W3C Sample',
	'screenshot': True
}

chromeOpts =  {
    'browserName': "chrome",
    'platformName': "Windows 10",
    'goog:chromeOptions': {'w3c': True},
    'tb:options': tbOptions
}

self.driver = webdriver.Remote(remote_url, desired_capabilities=chromeOpts)
Copy code
driver = await new webdriver.Builder().withCapabilities({
    "browserName": 'chrome',
    "platformName": 'Windows 10',
    /** Google requires "w3c" to be set in "goog:chromeOptions" as true if you're using ChromeDriver version 74 or lower.
     * Based on this commit: https://chromium.googlesource.com/chromium/src/+/2b49880e2481658e0702fd6fe494859bca52b39c
     * ChromeDriver now uses w3c by default from version 75+ so setting this option will no longer be a requirement **/
    "goog:chromeOptions" : { "w3c" : true },
    "tb:options": {
        "key": "api_key",
        "secret": "api_secret",
        "screenshot": true
    }
}).usingServer("https://hub.testingbot.com/wd/hub").build();
Copy code
var chromeOptions = new ChromeOptions()
{
    BrowserVersion = "81",
    PlatformName = "Windows 10",
    UseSpecCompliantProtocol = true
};
var tbOptions = new Dictionary<string, object>
{
    ["key"] = "api_key",
    ["secret"] = "api_secret",
    ["screenshot"] = true
};

chromeOptions.AddAdditionalCapability("tb:options", tbOptions, true);

driver = new RemoteWebDriver(new Uri("https://hub.testingbot.com/wd/hub"),
    chromeOptions.ToCapabilities(), TimeSpan.FromSeconds(600));
Value Type Default Value
boolean false

Make a video of your tests

By default we record a video of your test, which is accessible in the member area. If you do not wish to have this, you can disable it with this option.
Video should not slow down your test considerably.

Copy code
caps = Selenium::WebDriver::Remote::Capabilities.new
caps["screenrecorder"] = true
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("screenrecorder", true);
Copy code
$caps = array(
  "screenrecorder" => true
);
Copy code
capabilities = {
  "screenrecorder" : True
}
Copy code
const capabilities = {
  "screenrecorder" : true
}
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("screenrecorder", true);
Selenium W3C Example:
Copy code
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    screenrecorder: true
  }
}
Copy code
ChromeOptions chromeOpts = new ChromeOptions();
chromeOpts.setExperimentalOption("w3c", true);

MutableCapabilities tbOptions = new MutableCapabilities();
tbOptions.setCapability("key", "api_key");
tbOptions.setCapability("secret", "api_secret");
tbOptions.setCapability("screenrecorder", true);

DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(ChromeOptions.CAPABILITY, chromeOpts);
caps.setCapability("platformName", "Windows 10");
caps.setCapability("tb:options", tbOptions);
caps.setCapability("browserName", "chrome");
Copy code
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'screenrecorder' => true
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
Copy code
tbOptions = {
	'name': 'W3C Sample',
	'screenrecorder': True
}

chromeOpts =  {
    'browserName': "chrome",
    'platformName': "Windows 10",
    'goog:chromeOptions': {'w3c': True},
    'tb:options': tbOptions
}

self.driver = webdriver.Remote(remote_url, desired_capabilities=chromeOpts)
Copy code
driver = await new webdriver.Builder().withCapabilities({
    "browserName": 'chrome',
    "platformName": 'Windows 10',
    /** Google requires "w3c" to be set in "goog:chromeOptions" as true if you're using ChromeDriver version 74 or lower.
     * Based on this commit: https://chromium.googlesource.com/chromium/src/+/2b49880e2481658e0702fd6fe494859bca52b39c
     * ChromeDriver now uses w3c by default from version 75+ so setting this option will no longer be a requirement **/
    "goog:chromeOptions" : { "w3c" : true },
    "tb:options": {
        "key": "api_key",
        "secret": "api_secret",
        "screenrecorder": true
    }
}).usingServer("https://hub.testingbot.com/wd/hub").build();
Copy code
var chromeOptions = new ChromeOptions()
{
    BrowserVersion = "81",
    PlatformName = "Windows 10",
    UseSpecCompliantProtocol = true
};
var tbOptions = new Dictionary<string, object>
{
    ["key"] = "api_key",
    ["secret"] = "api_secret",
    ["screenrecorder"] = true
};

chromeOptions.AddAdditionalCapability("tb:options", tbOptions, true);

driver = new RemoteWebDriver(new Uri("https://hub.testingbot.com/wd/hub"),
    chromeOptions.ToCapabilities(), TimeSpan.FromSeconds(600));
Value Type Default Value
boolean true

Test Privacy

Make the test results for this test public so that everyone can access the results.

Copy code
caps = Selenium::WebDriver::Remote::Capabilities.new
caps["public"] = false
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("public", false);
Copy code
$caps = array(
  "public" => false
);
Copy code
capabilities = {
  "public" : False
}
Copy code
const capabilities = {
  "public" : false
}
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("public", false);
Selenium W3C Example:
Copy code
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "public" : false
  }
}
Copy code
ChromeOptions chromeOpts = new ChromeOptions();
chromeOpts.setExperimentalOption("w3c", true);

MutableCapabilities tbOptions = new MutableCapabilities();
tbOptions.setCapability("key", "api_key");
tbOptions.setCapability("secret", "api_secret");
tbOptions.setCapability("public", false);

DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(ChromeOptions.CAPABILITY, chromeOpts);
caps.setCapability("platformName", "Windows 10");
caps.setCapability("tb:options", tbOptions);
caps.setCapability("browserName", "chrome");
Copy code
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'public' => 130
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
Copy code
tbOptions = {
	'public': False
}

chromeOpts =  {
    'browserName': "chrome",
    'platformName': "Windows 10",
    'goog:chromeOptions': {'w3c': True},
    'tb:options': tbOptions
}

self.driver = webdriver.Remote(remote_url, desired_capabilities=chromeOpts)
Copy code
driver = await new webdriver.Builder().withCapabilities({
    "browserName": 'chrome',
    "platformName": 'Windows 10',
    /** Google requires "w3c" to be set in "goog:chromeOptions" as true if you're using ChromeDriver version 74 or lower.
     * Based on this commit: https://chromium.googlesource.com/chromium/src/+/2b49880e2481658e0702fd6fe494859bca52b39c
     * ChromeDriver now uses w3c by default from version 75+ so setting this option will no longer be a requirement **/
    "goog:chromeOptions" : { "w3c" : true },
    "tb:options": {
        "key": "api_key",
        "secret": "api_secret",
        "public": false
    }
}).usingServer("https://hub.testingbot.com/wd/hub").build();
Copy code
var chromeOptions = new ChromeOptions()
{
    BrowserVersion = "81",
    PlatformName = "Windows 10",
    UseSpecCompliantProtocol = true
};
var tbOptions = new Dictionary<string, object>
{
    ["key"] = "api_key",
    ["secret"] = "api_secret",
    ["public"] = false
};

chromeOptions.AddAdditionalCapability("tb:options", tbOptions, true);

driver = new RemoteWebDriver(new Uri("https://hub.testingbot.com/wd/hub"),
    chromeOptions.ToCapabilities(), TimeSpan.FromSeconds(600));
Value Type Default Value
boolean false

Blacklist hostnames

The hostnames you specify will be pointed to localhost instead of their real destination. This means you can speed up tests by blocking third party content which you don't need and slows down your test.

Copy code
caps = Selenium::WebDriver::Remote::Capabilities.new
caps["blacklist"] = "site1.com,site2.com"
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("blacklist", "site1.com,site2.com");
Copy code
$caps = array(
  "blacklist" => "site1.com,site2.com"
);
Copy code
capabilities = {
  "blacklist" : "site1.com,site2.com"
}
Copy code
const capabilities = {
  "blacklist" : "site1.com,site2.com"
}
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("blacklist", "site1.com,site2.com");
Selenium W3C Example:
Copy code
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "blacklist" : "site1.com,site2.com"
  }
}
Copy code
ChromeOptions chromeOpts = new ChromeOptions();
chromeOpts.setExperimentalOption("w3c", true);

MutableCapabilities tbOptions = new MutableCapabilities();
tbOptions.setCapability("key", "api_key");
tbOptions.setCapability("secret", "api_secret");
tbOptions.setCapability("blacklist", "site1.com,site2.com");

DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(ChromeOptions.CAPABILITY, chromeOpts);
caps.setCapability("platformName", "Windows 10");
caps.setCapability("tb:options", tbOptions);
caps.setCapability("browserName", "chrome");
Copy code
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'blacklist' => "site1.com,site2.com"
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
Copy code
tbOptions = {
	'blacklist': "site1.com,site2.com"
}

chromeOpts =  {
    'browserName': "chrome",
    'platformName': "Windows 10",
    'goog:chromeOptions': {'w3c': True},
    'tb:options': tbOptions
}

self.driver = webdriver.Remote(remote_url, desired_capabilities=chromeOpts)
Copy code
driver = await new webdriver.Builder().withCapabilities({
    "browserName": 'chrome',
    "platformName": 'Windows 10',
    /** Google requires "w3c" to be set in "goog:chromeOptions" as true if you're using ChromeDriver version 74 or lower.
     * Based on this commit: https://chromium.googlesource.com/chromium/src/+/2b49880e2481658e0702fd6fe494859bca52b39c
     * ChromeDriver now uses w3c by default from version 75+ so setting this option will no longer be a requirement **/
    "goog:chromeOptions" : { "w3c" : true },
    "tb:options": {
        "key": "api_key",
        "secret": "api_secret",
        "blacklist": "site1.com,site2.com"
    }
}).usingServer("https://hub.testingbot.com/wd/hub").build();
Copy code
var chromeOptions = new ChromeOptions()
{
    BrowserVersion = "81",
    PlatformName = "Windows 10",
    UseSpecCompliantProtocol = true
};
var tbOptions = new Dictionary<string, object>
{
    ["key"] = "api_key",
    ["secret"] = "api_secret",
    ["blacklist"] = "site1.com,site2.com"
};

chromeOptions.AddAdditionalCapability("tb:options", tbOptions, true);

driver = new RemoteWebDriver(new Uri("https://hub.testingbot.com/wd/hub"),
    chromeOptions.ToCapabilities(), TimeSpan.FromSeconds(600));
Value Type
string (comma-separated)

Customize Logging

By default, TestingBot records logs of all Selenium actions and its drivers.

Set this option to false if you don't want TestingBot to record anything (for example, if you have sensitive data).
You will not see any test logs in our member dashboard.
Set to strip-parameters to prevent the POST/GET parameters from being logged on the TestingBot test detail page (does not affect other logs like Selenium logs, Chromedriver logs, ...).

Copy code
caps = Selenium::WebDriver::Remote::Capabilities.new
caps["recordLogs"] = true
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("recordLogs", true);
Copy code
$caps = array(
  "recordLogs" => true
);
Copy code
capabilities = {
  "recordLogs" : True
}
Copy code
const capabilities = {
  "recordLogs" : true
}
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("recordLogs", true);
Selenium W3C Example:
Copy code
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "recordLogs" : true
  }
}
Copy code
ChromeOptions chromeOpts = new ChromeOptions();
chromeOpts.setExperimentalOption("w3c", true);

MutableCapabilities tbOptions = new MutableCapabilities();
tbOptions.setCapability("key", "api_key");
tbOptions.setCapability("secret", "api_secret");
tbOptions.setCapability("recordLogs", true);

DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(ChromeOptions.CAPABILITY, chromeOpts);
caps.setCapability("platformName", "Windows 10");
caps.setCapability("tb:options", tbOptions);
caps.setCapability("browserName", "chrome");
Copy code
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'recordLogs' => true
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
Copy code
tbOptions = {
	'recordLogs': True
}

chromeOpts =  {
    'browserName': "chrome",
    'platformName': "Windows 10",
    'goog:chromeOptions': {'w3c': True},
    'tb:options': tbOptions
}

self.driver = webdriver.Remote(remote_url, desired_capabilities=chromeOpts)
Copy code
driver = await new webdriver.Builder().withCapabilities({
    "browserName": 'chrome',
    "platformName": 'Windows 10',
    /** Google requires "w3c" to be set in "goog:chromeOptions" as true if you're using ChromeDriver version 74 or lower.
     * Based on this commit: https://chromium.googlesource.com/chromium/src/+/2b49880e2481658e0702fd6fe494859bca52b39c
     * ChromeDriver now uses w3c by default from version 75+ so setting this option will no longer be a requirement **/
    "goog:chromeOptions" : { "w3c" : true },
    "tb:options": {
        "key": "api_key",
        "secret": "api_secret",
        "recordLogs": true
    }
}).usingServer("https://hub.testingbot.com/wd/hub").build();
Copy code
var chromeOptions = new ChromeOptions()
{
    BrowserVersion = "81",
    PlatformName = "Windows 10",
    UseSpecCompliantProtocol = true
};
var tbOptions = new Dictionary<string, object>
{
    ["key"] = "api_key",
    ["secret"] = "api_secret",
    ["recordLogs"] = true
};

chromeOptions.AddAdditionalCapability("tb:options", tbOptions, true);

driver = new RemoteWebDriver(new Uri("https://hub.testingbot.com/wd/hub"),
    chromeOptions.ToCapabilities(), TimeSpan.FromSeconds(600));
Value Type Default Value Possible Values:
string "true" true, false, or strip-parameters

Custom Time Zones

Change the Time Zone of the Virtual Machine to the Time Zone you specify. You can find a list of timezones on Wikipedia. Only location names are supported (not their paths). See some examples below:

Copy code
caps = Selenium::WebDriver::Remote::Capabilities.new
caps["timeZone"] = "Etc/UTC"
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("timeZone", "Etc/UTC");
Copy code
$caps = array(
  "timeZone" => "Etc/UTC"
);
Copy code
capabilities = {
  "timeZone" : "Etc/UTC"
}
Copy code
const capabilities = {
  "timeZone" : "Etc/UTC"
}
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("timeZone", "Etc/UTC");
Selenium W3C Example:
Copy code
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "timeZone" : "Etc/UTC"
  }
}
Copy code
ChromeOptions chromeOpts = new ChromeOptions();
chromeOpts.setExperimentalOption("w3c", true);

MutableCapabilities tbOptions = new MutableCapabilities();
tbOptions.setCapability("key", "api_key");
tbOptions.setCapability("secret", "api_secret");
tbOptions.setCapability("timeZone", "Etc/UTC");

DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(ChromeOptions.CAPABILITY, chromeOpts);
caps.setCapability("platformName", "Windows 10");
caps.setCapability("tb:options", tbOptions);
caps.setCapability("browserName", "chrome");
Copy code
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'timeZone' => "Etc/UTC"
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
Copy code
tbOptions = {
	'timeZone': "Etc/UTC"
}

chromeOpts =  {
    'browserName': "chrome",
    'platformName': "Windows 10",
    'goog:chromeOptions': {'w3c': True},
    'tb:options': tbOptions
}

self.driver = webdriver.Remote(remote_url, desired_capabilities=chromeOpts)
Copy code
driver = await new webdriver.Builder().withCapabilities({
    "browserName": 'chrome',
    "platformName": 'Windows 10',
    /** Google requires "w3c" to be set in "goog:chromeOptions" as true if you're using ChromeDriver version 74 or lower.
     * Based on this commit: https://chromium.googlesource.com/chromium/src/+/2b49880e2481658e0702fd6fe494859bca52b39c
     * ChromeDriver now uses w3c by default from version 75+ so setting this option will no longer be a requirement **/
    "goog:chromeOptions" : { "w3c" : true },
    "tb:options": {
        "key": "api_key",
        "secret": "api_secret",
        "timeZone": "Etc/UTC"
    }
}).usingServer("https://hub.testingbot.com/wd/hub").build();
Copy code
var chromeOptions = new ChromeOptions()
{
    BrowserVersion = "81",
    PlatformName = "Windows 10",
    UseSpecCompliantProtocol = true
};
var tbOptions = new Dictionary<string, object>
{
    ["key"] = "api_key",
    ["secret"] = "api_secret",
    ["timeZone"] = "Etc/UTC"
};

chromeOptions.AddAdditionalCapability("tb:options", tbOptions, true);

driver = new RemoteWebDriver(new Uri("https://hub.testingbot.com/wd/hub"),
    chromeOptions.ToCapabilities(), TimeSpan.FromSeconds(600));
Value Type Default Value Possible Values:
string "Etc/UTC" List of timezones

Change Screen Resolution

Will adjust the screen resolution during your test.

Copy code
caps = Selenium::WebDriver::Remote::Capabilities.new
caps["screen-resolution"] = "1280x1024"
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("screen-resolution", "1280x1024");
Copy code
$caps = array(
  "screen-resolution" => "1280x1024"
);
Copy code
capabilities = {
  "screen-resolution" : "1280x1024"
}
Copy code
const capabilities = {
  "screen-resolution" : "1280x1024"
}
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("screen-resolution", "1280x1024");
Selenium W3C Example:
Copy code
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "screen-resolution" : "1280x1024"
  }
}
Copy code
ChromeOptions chromeOpts = new ChromeOptions();
chromeOpts.setExperimentalOption("w3c", true);

MutableCapabilities tbOptions = new MutableCapabilities();
tbOptions.setCapability("key", "api_key");
tbOptions.setCapability("secret", "api_secret");
tbOptions.setCapability("screen-resolution", "1280x1024");

DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(ChromeOptions.CAPABILITY, chromeOpts);
caps.setCapability("platformName", "Windows 10");
caps.setCapability("tb:options", tbOptions);
caps.setCapability("browserName", "chrome");
Copy code
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'screen-resolution' => "1280x1024"
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
Copy code
tbOptions = {
	'screen-resolution': "My Test Name"
}

chromeOpts =  {
    'browserName': "chrome",
    'platformName': "Windows 10",
    'goog:chromeOptions': {'w3c': True},
    'tb:options': tbOptions
}

self.driver = webdriver.Remote(remote_url, desired_capabilities=chromeOpts)
Copy code
driver = await new webdriver.Builder().withCapabilities({
    "browserName": 'chrome',
    "platformName": 'Windows 10',
    /** Google requires "w3c" to be set in "goog:chromeOptions" as true if you're using ChromeDriver version 74 or lower.
     * Based on this commit: https://chromium.googlesource.com/chromium/src/+/2b49880e2481658e0702fd6fe494859bca52b39c
     * ChromeDriver now uses w3c by default from version 75+ so setting this option will no longer be a requirement **/
    "goog:chromeOptions" : { "w3c" : true },
    "tb:options": {
        "key": "api_key",
        "secret": "api_secret",
        "screen-resolution": "1280x1024"
    }
}).usingServer("https://hub.testingbot.com/wd/hub").build();
Copy code
var chromeOptions = new ChromeOptions()
{
    BrowserVersion = "81",
    PlatformName = "Windows 10",
    UseSpecCompliantProtocol = true
};
var tbOptions = new Dictionary<string, object>
{
    ["key"] = "api_key",
    ["secret"] = "api_secret",
    ["screen-resolution"] = "1280x1024"
};

chromeOptions.AddAdditionalCapability("tb:options", tbOptions, true);

driver = new RemoteWebDriver(new Uri("https://hub.testingbot.com/wd/hub"),
    chromeOptions.ToCapabilities(), TimeSpan.FromSeconds(600));
Value Type Default Value
string "1280x1024"
Platform Resolutions
Windows/Linux
  • 800x600
  • 1024x768
  • 1152x864
  • 1280x768
  • 1280x800
  • 1280x960
  • 1280x1024
  • 1400x1050
  • 1600x1200
  • 1680x1050
  • 1920x1080
  • 1920x1200
  • 2560x1440
macOS
  • 800x600
  • 1024x768
  • 1280x768
  • 1280x800
  • 1280x960
  • 1280x1024
  • 1366x768
  • 1440x900
  • 1600x900
  • 1600x1200
  • 1680x1050
  • 1920x1080
  • 1920x1200
  • 2048x1536

Customize OS

When you specify a prerun file, we will first download the file and execute it (with optional prerun-arguments).
This is useful when you want to customize/add software before your test starts.

Copy code
caps = Selenium::WebDriver::Remote::Capabilities.new
caps["prerun"] = "https://..."
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("prerun", "https://...");
Copy code
$caps = array(
  "prerun" => "https://..."
);
Copy code
capabilities = {
  "prerun" : "https://..."
}
Copy code
const capabilities = {
  "prerun" : "https://..."
}
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("prerun", "https://...");
Selenium W3C Example:
Copy code
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "prerun" : "https://..."
  }
}
Copy code
ChromeOptions chromeOpts = new ChromeOptions();
chromeOpts.setExperimentalOption("w3c", true);

MutableCapabilities tbOptions = new MutableCapabilities();
tbOptions.setCapability("key", "api_key");
tbOptions.setCapability("secret", "api_secret");
tbOptions.setCapability("prerun", "https://...");

DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(ChromeOptions.CAPABILITY, chromeOpts);
caps.setCapability("platformName", "Windows 10");
caps.setCapability("tb:options", tbOptions);
caps.setCapability("browserName", "chrome");
Copy code
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'prerun' => "https://..."
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
Copy code
tbOptions = {
	'prerun': "https://..."
}

chromeOpts =  {
    'browserName': "chrome",
    'platformName': "Windows 10",
    'goog:chromeOptions': {'w3c': True},
    'tb:options': tbOptions
}

self.driver = webdriver.Remote(remote_url, desired_capabilities=chromeOpts)
Copy code
driver = await new webdriver.Builder().withCapabilities({
    "browserName": 'chrome',
    "platformName": 'Windows 10',
    /** Google requires "w3c" to be set in "goog:chromeOptions" as true if you're using ChromeDriver version 74 or lower.
     * Based on this commit: https://chromium.googlesource.com/chromium/src/+/2b49880e2481658e0702fd6fe494859bca52b39c
     * ChromeDriver now uses w3c by default from version 75+ so setting this option will no longer be a requirement **/
    "goog:chromeOptions" : { "w3c" : true },
    "tb:options": {
        "key": "api_key",
        "secret": "api_secret",
        "prerun": "https://..."
    }
}).usingServer("https://hub.testingbot.com/wd/hub").build();
Copy code
var chromeOptions = new ChromeOptions()
{
    BrowserVersion = "81",
    PlatformName = "Windows 10",
    UseSpecCompliantProtocol = true
};
var tbOptions = new Dictionary<string, object>
{
    ["key"] = "api_key",
    ["secret"] = "api_secret",
    ["prerun"] = "https://..."
};

chromeOptions.AddAdditionalCapability("tb:options", tbOptions, true);

driver = new RemoteWebDriver(new Uri("https://hub.testingbot.com/wd/hub"),
    chromeOptions.ToCapabilities(), TimeSpan.FromSeconds(600));
Value Type
string (URL)
Copy code
"prerun-args" : "-a -b -c ..."
Value Type
string

With TestingBot Storage, you can upload your executable on our servers.
The advantage of this is that our test VMs can immediately download your executable from our own network, which is much faster than downloading from the public internet.
Once the file is uploaded via TestingBot Storage, you can use "prerun" : "tb://..."

Edit hostnames

You can specify an array of objects containing the keys ip and domain. We will write these values to the hosts file of the VM.

Copy code
caps = Selenium::WebDriver::Remote::Capabilities.new
caps["hosts"] = [{ ip: '127.0.0.1', domain: 'mydomain' }]
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("hosts", [{ ip: '127.0.0.1', domain: 'mydomain' }]);
Copy code
$caps = array(
  "hosts" => [{ ip: '127.0.0.1', domain: 'mydomain' }]
);
Copy code
capabilities = {
  "hosts" : [{ ip: '127.0.0.1', domain: 'mydomain' }]
}
Copy code
const capabilities = {
  "hosts" : [{ ip: '127.0.0.1', domain: 'mydomain' }]
}
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("hosts", [{ ip: '127.0.0.1', domain: 'mydomain' }]);
Selenium W3C Example:
Copy code
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "hosts" : [{ ip: '127.0.0.1', domain: 'mydomain' }]
  }
}
Copy code
ChromeOptions chromeOpts = new ChromeOptions();
chromeOpts.setExperimentalOption("w3c", true);

MutableCapabilities tbOptions = new MutableCapabilities();
tbOptions.setCapability("key", "api_key");
tbOptions.setCapability("secret", "api_secret");
tbOptions.setCapability("hosts", [{ ip: '127.0.0.1', domain: 'mydomain' }]);

DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(ChromeOptions.CAPABILITY, chromeOpts);
caps.setCapability("platformName", "Windows 10");
caps.setCapability("tb:options", tbOptions);
caps.setCapability("browserName", "chrome");
Copy code
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'hosts' => [{ ip: '127.0.0.1', domain: 'mydomain' }]
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
Copy code
tbOptions = {
	'hosts': [{ ip: '127.0.0.1', domain: 'mydomain' }]
}

chromeOpts =  {
    'browserName': "chrome",
    'platformName': "Windows 10",
    'goog:chromeOptions': {'w3c': True},
    'tb:options': tbOptions
}

self.driver = webdriver.Remote(remote_url, desired_capabilities=chromeOpts)
Copy code
driver = await new webdriver.Builder().withCapabilities({
    "browserName": 'chrome',
    "platformName": 'Windows 10',
    /** Google requires "w3c" to be set in "goog:chromeOptions" as true if you're using ChromeDriver version 74 or lower.
     * Based on this commit: https://chromium.googlesource.com/chromium/src/+/2b49880e2481658e0702fd6fe494859bca52b39c
     * ChromeDriver now uses w3c by default from version 75+ so setting this option will no longer be a requirement **/
    "goog:chromeOptions" : { "w3c" : true },
    "tb:options": {
        "key": "api_key",
        "secret": "api_secret",
        "hosts": [{ ip: '127.0.0.1', domain: 'mydomain' }]
    }
}).usingServer("https://hub.testingbot.com/wd/hub").build();
Copy code
var chromeOptions = new ChromeOptions()
{
    BrowserVersion = "81",
    PlatformName = "Windows 10",
    UseSpecCompliantProtocol = true
};
var tbOptions = new Dictionary<string, object>
{
    ["key"] = "api_key",
    ["secret"] = "api_secret",
    ["hosts"] = [{ ip: '127.0.0.1', domain: 'mydomain' }]
};

chromeOptions.AddAdditionalCapability("tb:options", tbOptions, true);

driver = new RemoteWebDriver(new Uri("https://hub.testingbot.com/wd/hub"),
    chromeOptions.ToCapabilities(), TimeSpan.FromSeconds(600));
Value Type
array of objects ({ ip: "", domain: "" })

Upload file

When you specify an URL (upload) and fileName (uploadFilepath), we will automatically download the file from the URL and save it in the uploadFilepath.

Copy code
caps = Selenium::WebDriver::Remote::Capabilities.new
caps["upload"] = "https://..."
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("upload", "https://...");
Copy code
$caps = array(
  "upload" => "https://..."
);
Copy code
capabilities = {
  "upload" : "https://..."
}
Copy code
const capabilities = {
  "upload" : "https://..."
}
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("upload", "https://...");
Selenium W3C Example:
Copy code
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "upload" : "https://..."
  }
}
Copy code
ChromeOptions chromeOpts = new ChromeOptions();
chromeOpts.setExperimentalOption("w3c", true);

MutableCapabilities tbOptions = new MutableCapabilities();
tbOptions.setCapability("key", "api_key");
tbOptions.setCapability("secret", "api_secret");
tbOptions.setCapability("upload", "https://...");

DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(ChromeOptions.CAPABILITY, chromeOpts);
caps.setCapability("platformName", "Windows 10");
caps.setCapability("tb:options", tbOptions);
caps.setCapability("browserName", "chrome");
Copy code
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'upload' => "https://..."
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
Copy code
tbOptions = {
	'upload': "https://..."
}

chromeOpts =  {
    'browserName': "chrome",
    'platformName': "Windows 10",
    'goog:chromeOptions': {'w3c': True},
    'tb:options': tbOptions
}

self.driver = webdriver.Remote(remote_url, desired_capabilities=chromeOpts)
Copy code
driver = await new webdriver.Builder().withCapabilities({
    "browserName": 'chrome',
    "platformName": 'Windows 10',
    /** Google requires "w3c" to be set in "goog:chromeOptions" as true if you're using ChromeDriver version 74 or lower.
     * Based on this commit: https://chromium.googlesource.com/chromium/src/+/2b49880e2481658e0702fd6fe494859bca52b39c
     * ChromeDriver now uses w3c by default from version 75+ so setting this option will no longer be a requirement **/
    "goog:chromeOptions" : { "w3c" : true },
    "tb:options": {
        "key": "api_key",
        "secret": "api_secret",
        "upload": "https://..."
    }
}).usingServer("https://hub.testingbot.com/wd/hub").build();
Copy code
var chromeOptions = new ChromeOptions()
{
    BrowserVersion = "81",
    PlatformName = "Windows 10",
    UseSpecCompliantProtocol = true
};
var tbOptions = new Dictionary<string, object>
{
    ["key"] = "api_key",
    ["secret"] = "api_secret",
    ["upload"] = "https://..."
};

chromeOptions.AddAdditionalCapability("tb:options", tbOptions, true);

driver = new RemoteWebDriver(new Uri("https://hub.testingbot.com/wd/hub"),
    chromeOptions.ToCapabilities(), TimeSpan.FromSeconds(600));
Value Type
string (URL)

We recommend using these directories to save your files: For Windows (C:\test\), for Linux/macOS: (/tmp/).

You can also use the home directory tilde to specify the user's directory: ~/Desktop/sample.pdf

Example:
Copy code
"uploadFilepath" : "C:\\test\\myfile.ext"
Example (Selenium 4):
Copy code
"tb:options" : {
	"uploadFilepath" : "C:\\test\\myfile.ext"
}
Value Type
string (URL)

Upload Multiple Files

Specify an array of objects, containing keys url and filePath. We will automatically download these files and put them in the filePaths you specify.

We recommend using these directories to save your files: For Windows (C:\test\), for Linux/macOS: (/tmp/).

You can also use the home directory tilde to specify the user's directory: ~/Desktop/sample.pdf

Copy code
caps = Selenium::WebDriver::Remote::Capabilities.new
caps["uploadMultiple"] = [{ url: "", filePath: "" }]
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("uploadMultiple", [{ url: "", filePath: "" }]);
Copy code
$caps = array(
  "uploadMultiple" => [{ url: "", filePath: "" }]
);
Copy code
capabilities = {
  "uploadMultiple" : [{ url: "", filePath: "" }]
}
Copy code
const capabilities = {
  "uploadMultiple" : [{ url: "", filePath: "" }]
}
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("uploadMultiple", [{ url: "", filePath: "" }]);
Selenium W3C Example:
Copy code
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "uploadMultiple" : [{ url: "", filePath: "" }]
  }
}
Copy code
ChromeOptions chromeOpts = new ChromeOptions();
chromeOpts.setExperimentalOption("w3c", true);

MutableCapabilities tbOptions = new MutableCapabilities();
tbOptions.setCapability("key", "api_key");
tbOptions.setCapability("secret", "api_secret");
tbOptions.setCapability("uploadMultiple", [{ url: "", filePath: "" }]);

DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(ChromeOptions.CAPABILITY, chromeOpts);
caps.setCapability("platformName", "Windows 10");
caps.setCapability("tb:options", tbOptions);
caps.setCapability("browserName", "chrome");
Copy code
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'uploadMultiple' => [{ url: "", filePath: "" }]
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
Copy code
tbOptions = {
	'uploadMultiple': [{ url: "", filePath: "" }]
}

chromeOpts =  {
    'browserName': "chrome",
    'platformName': "Windows 10",
    'goog:chromeOptions': {'w3c': True},
    'tb:options': tbOptions
}

self.driver = webdriver.Remote(remote_url, desired_capabilities=chromeOpts)
Copy code
driver = await new webdriver.Builder().withCapabilities({
    "browserName": 'chrome',
    "platformName": 'Windows 10',
    /** Google requires "w3c" to be set in "goog:chromeOptions" as true if you're using ChromeDriver version 74 or lower.
     * Based on this commit: https://chromium.googlesource.com/chromium/src/+/2b49880e2481658e0702fd6fe494859bca52b39c
     * ChromeDriver now uses w3c by default from version 75+ so setting this option will no longer be a requirement **/
    "goog:chromeOptions" : { "w3c" : true },
    "tb:options": {
        "key": "api_key",
        "secret": "api_secret",
        "uploadMultiple": [{ url: "", filePath: "" }]
    }
}).usingServer("https://hub.testingbot.com/wd/hub").build();
Copy code
var chromeOptions = new ChromeOptions()
{
    BrowserVersion = "81",
    PlatformName = "Windows 10",
    UseSpecCompliantProtocol = true
};
var tbOptions = new Dictionary<string, object>
{
    ["key"] = "api_key",
    ["secret"] = "api_secret",
    ["uploadMultiple"] = [{ url: "", filePath: "" }]
};

chromeOptions.AddAdditionalCapability("tb:options", tbOptions, true);

driver = new RemoteWebDriver(new Uri("https://hub.testingbot.com/wd/hub"),
    chromeOptions.ToCapabilities(), TimeSpan.FromSeconds(600));
Value Type
array of objects, { url: "", filePath: "" }

Geolocation Testing

We provide an option where you can specify from which country you'd like to run the test from.

Once you specify this option, the virtual machine we provision for your test will be configured to use a proxy in the country you specified.

Copy code
caps = Selenium::WebDriver::Remote::Capabilities.new
caps["testingbot.geoCountryCode"] = "DE"
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("testingbot.geoCountryCode", "DE");
Copy code
$caps = array(
  "testingbot.geoCountryCode" => "DE"
);
Copy code
capabilities = {
  "testingbot.geoCountryCode" : "DE"
}
Copy code
const capabilities = {
  "testingbot.geoCountryCode" : "DE"
}
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("testingbot.geoCountryCode", "DE");
Selenium W3C Example:
Copy code
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "testingbot.geoCountryCode" : "DE"
  }
}
Copy code
ChromeOptions chromeOpts = new ChromeOptions();
chromeOpts.setExperimentalOption("w3c", true);

MutableCapabilities tbOptions = new MutableCapabilities();
tbOptions.setCapability("key", "api_key");
tbOptions.setCapability("secret", "api_secret");
tbOptions.setCapability("testingbot.geoCountryCode", "DE");

DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(ChromeOptions.CAPABILITY, chromeOpts);
caps.setCapability("platformName", "Windows 10");
caps.setCapability("tb:options", tbOptions);
caps.setCapability("browserName", "chrome");
Copy code
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'testingbot.geoCountryCode' => "DE"
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
Copy code
tbOptions = {
	'testingbot.geoCountryCode': "DE"
}

chromeOpts =  {
    'browserName': "chrome",
    'platformName': "Windows 10",
    'goog:chromeOptions': {'w3c': True},
    'tb:options': tbOptions
}

self.driver = webdriver.Remote(remote_url, desired_capabilities=chromeOpts)
Copy code
driver = await new webdriver.Builder().withCapabilities({
    "browserName": 'chrome',
    "platformName": 'Windows 10',
    /** Google requires "w3c" to be set in "goog:chromeOptions" as true if you're using ChromeDriver version 74 or lower.
     * Based on this commit: https://chromium.googlesource.com/chromium/src/+/2b49880e2481658e0702fd6fe494859bca52b39c
     * ChromeDriver now uses w3c by default from version 75+ so setting this option will no longer be a requirement **/
    "goog:chromeOptions" : { "w3c" : true },
    "tb:options": {
        "key": "api_key",
        "secret": "api_secret",
        "testingbot.geoCountryCode": "DE"
    }
}).usingServer("https://hub.testingbot.com/wd/hub").build();
Copy code
var chromeOptions = new ChromeOptions()
{
    BrowserVersion = "81",
    PlatformName = "Windows 10",
    UseSpecCompliantProtocol = true
};
var tbOptions = new Dictionary<string, object>
{
    ["key"] = "api_key",
    ["secret"] = "api_secret",
    ["testingbot.geoCountryCode"] = "DE"
};

chromeOptions.AddAdditionalCapability("tb:options", tbOptions, true);

driver = new RemoteWebDriver(new Uri("https://hub.testingbot.com/wd/hub"),
    chromeOptions.ToCapabilities(), TimeSpan.FromSeconds(600));

Specify testingbot.geoCountryCode with one of the following country codes:

  • '*': this will take a random country from the list below
  • 'AU': Australia
  • 'BH': Bahrain
  • 'BE': Belgium
  • 'BR': Brazil
  • 'CN': China
  • 'FR': France
  • 'DE': Germany
  • 'IN': India
  • 'IT': Italy
  • 'JP': Japan
  • 'SG': Singapore
  • 'ZA': South Africa
  • 'ES': Spain
  • 'SE': Sweden
  • 'AE': United Arab Emirates
  • 'GB': United Kingdom
  • 'US': United States

Important: this does not work on Android 4.4

Change Test Name

Add a name to this test, which will show up in our member area and API.

Copy code
caps = Selenium::WebDriver::Remote::Capabilities.new
caps["name"] = "My Test Name"
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("name", "My Test Name");
Copy code
$caps = array(
  "name" => "My Test Name"
);
Copy code
capabilities = {
  "name" : "My Test Name"
}
Copy code
const capabilities = {
  "name" : "My Test Name"
}
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("name", "My Test Name");
Selenium W3C Example:
Copy code
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "name" : "My Test Name"
  }
}
Copy code
ChromeOptions chromeOpts = new ChromeOptions();
chromeOpts.setExperimentalOption("w3c", true);

MutableCapabilities tbOptions = new MutableCapabilities();
tbOptions.setCapability("key", "api_key");
tbOptions.setCapability("secret", "api_secret");
tbOptions.setCapability("name", "My Test Name");

DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(ChromeOptions.CAPABILITY, chromeOpts);
caps.setCapability("platformName", "Windows 10");
caps.setCapability("tb:options", tbOptions);
caps.setCapability("browserName", "chrome");
Copy code
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'name' => "My Test Name"
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
Copy code
tbOptions = {
	'name': "My Test Name"
}

chromeOpts =  {
    'browserName': "chrome",
    'platformName': "Windows 10",
    'goog:chromeOptions': {'w3c': True},
    'tb:options': tbOptions
}

self.driver = webdriver.Remote(remote_url, desired_capabilities=chromeOpts)
Copy code
driver = await new webdriver.Builder().withCapabilities({
    "browserName": 'chrome',
    "platformName": 'Windows 10',
    /** Google requires "w3c" to be set in "goog:chromeOptions" as true if you're using ChromeDriver version 74 or lower.
     * Based on this commit: https://chromium.googlesource.com/chromium/src/+/2b49880e2481658e0702fd6fe494859bca52b39c
     * ChromeDriver now uses w3c by default from version 75+ so setting this option will no longer be a requirement **/
    "goog:chromeOptions" : { "w3c" : true },
    "tb:options": {
        "key": "api_key",
        "secret": "api_secret",
        "name": "My Test Name"
    }
}).usingServer("https://hub.testingbot.com/wd/hub").build();
Copy code
var chromeOptions = new ChromeOptions()
{
    BrowserVersion = "81",
    PlatformName = "Windows 10",
    UseSpecCompliantProtocol = true
};
var tbOptions = new Dictionary<string, object>
{
    ["key"] = "api_key",
    ["secret"] = "api_secret",
    ["name"] = "My Test Name"
};

chromeOptions.AddAdditionalCapability("tb:options", tbOptions, true);

driver = new RemoteWebDriver(new Uri("https://hub.testingbot.com/wd/hub"),
    chromeOptions.ToCapabilities(), TimeSpan.FromSeconds(600));
Value Type Default Value
string unnamed test

Group Tests

A key you can use to group certain tests in the same build (for example in Jenkins).
The builds will appear in our member area.

Copy code
caps = Selenium::WebDriver::Remote::Capabilities.new
caps["build"] = "My First Build"
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("build", "My First Build");
Copy code
$caps = array(
  "build" => "My First Build"
);
Copy code
capabilities = {
  "build" : "My First Build"
}
Copy code
const capabilities = {
  "build" : "My First Build"
}
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("build", "My First Build");
Selenium W3C Example:
Copy code
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "build" : "My First Build"
  }
}
Copy code
ChromeOptions chromeOpts = new ChromeOptions();
chromeOpts.setExperimentalOption("w3c", true);

MutableCapabilities tbOptions = new MutableCapabilities();
tbOptions.setCapability("key", "api_key");
tbOptions.setCapability("secret", "api_secret");
tbOptions.setCapability("build", "My First Build");

DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(ChromeOptions.CAPABILITY, chromeOpts);
caps.setCapability("platformName", "Windows 10");
caps.setCapability("tb:options", tbOptions);
caps.setCapability("browserName", "chrome");
Copy code
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'build' => "My First Build"
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
Copy code
tbOptions = {
	'build': "My First Build"
}

chromeOpts =  {
    'browserName': "chrome",
    'platformName': "Windows 10",
    'goog:chromeOptions': {'w3c': True},
    'tb:options': tbOptions
}

self.driver = webdriver.Remote(remote_url, desired_capabilities=chromeOpts)
Copy code
driver = await new webdriver.Builder().withCapabilities({
    "browserName": 'chrome',
    "platformName": 'Windows 10',
    /** Google requires "w3c" to be set in "goog:chromeOptions" as true if you're using ChromeDriver version 74 or lower.
     * Based on this commit: https://chromium.googlesource.com/chromium/src/+/2b49880e2481658e0702fd6fe494859bca52b39c
     * ChromeDriver now uses w3c by default from version 75+ so setting this option will no longer be a requirement **/
    "goog:chromeOptions" : { "w3c" : true },
    "tb:options": {
        "key": "api_key",
        "secret": "api_secret",
        "build": "My First Build"
    }
}).usingServer("https://hub.testingbot.com/wd/hub").build();
Copy code
var chromeOptions = new ChromeOptions()
{
    BrowserVersion = "81",
    PlatformName = "Windows 10",
    UseSpecCompliantProtocol = true
};
var tbOptions = new Dictionary<string, object>
{
    ["key"] = "api_key",
    ["secret"] = "api_secret",
    ["build"] = "My First Build"
};

chromeOptions.AddAdditionalCapability("tb:options", tbOptions, true);

driver = new RemoteWebDriver(new Uri("https://hub.testingbot.com/wd/hub"),
    chromeOptions.ToCapabilities(), TimeSpan.FromSeconds(600));
Value Type
string

Idle Timeout

The maximum amount of time a browser will wait before proceeding to the next step in your test.

Copy code
caps = Selenium::WebDriver::Remote::Capabilities.new
caps["idletimeout"] = 130
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("idletimeout", 130);
Copy code
$caps = array(
  "idletimeout" => 130
);
Copy code
capabilities = {
  "idletimeout" : 130
}
Copy code
const capabilities = {
  "idletimeout" : 130
}
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("idletimeout", 130);
Selenium W3C Example:
Copy code
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "idletimeout" : 130
  }
}
Copy code
ChromeOptions chromeOpts = new ChromeOptions();
chromeOpts.setExperimentalOption("w3c", true);

MutableCapabilities tbOptions = new MutableCapabilities();
tbOptions.setCapability("key", "api_key");
tbOptions.setCapability("secret", "api_secret");
tbOptions.setCapability("idletimeout", 130);

DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(ChromeOptions.CAPABILITY, chromeOpts);
caps.setCapability("platformName", "Windows 10");
caps.setCapability("tb:options", tbOptions);
caps.setCapability("browserName", "chrome");
Copy code
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'idletimeout' => 130
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
Copy code
tbOptions = {
	'idletimeout': 130
}

chromeOpts =  {
    'browserName': "chrome",
    'platformName': "Windows 10",
    'goog:chromeOptions': {'w3c': True},
    'tb:options': tbOptions
}

self.driver = webdriver.Remote(remote_url, desired_capabilities=chromeOpts)
Copy code
driver = await new webdriver.Builder().withCapabilities({
    "browserName": 'chrome',
    "platformName": 'Windows 10',
    /** Google requires "w3c" to be set in "goog:chromeOptions" as true if you're using ChromeDriver version 74 or lower.
     * Based on this commit: https://chromium.googlesource.com/chromium/src/+/2b49880e2481658e0702fd6fe494859bca52b39c
     * ChromeDriver now uses w3c by default from version 75+ so setting this option will no longer be a requirement **/
    "goog:chromeOptions" : { "w3c" : true },
    "tb:options": {
        "key": "api_key",
        "secret": "api_secret",
        "idletimeout": 130
    }
}).usingServer("https://hub.testingbot.com/wd/hub").build();
Copy code
var chromeOptions = new ChromeOptions()
{
    BrowserVersion = "81",
    PlatformName = "Windows 10",
    UseSpecCompliantProtocol = true
};
var tbOptions = new Dictionary<string, object>
{
    ["key"] = "api_key",
    ["secret"] = "api_secret",
    ["idletimeout"] = 130
};

chromeOptions.AddAdditionalCapability("tb:options", tbOptions, true);

driver = new RemoteWebDriver(new Uri("https://hub.testingbot.com/wd/hub"),
    chromeOptions.ToCapabilities(), TimeSpan.FromSeconds(600));
Value Type Default Value
int (specify number of seconds) 130 seconds

Maximum Test Duration

The maximum duration for a single test. This is a safeguard to prevent bad tests from using up your credits.

We generally recommend to keep tests short (less than 10 minutes). It's better to split up large tests in smaller individual tests.
This keeps your tests fast and allows for more parallelization of your tests.

Copy code
caps = Selenium::WebDriver::Remote::Capabilities.new
caps["maxduration"] = 1800
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("maxduration", 1800);
Copy code
$caps = array(
  "maxduration" => 1800
);
Copy code
capabilities = {
  "maxduration" : 1800
}
Copy code
const capabilities = {
  "maxduration" : 1800
}
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("maxduration", 1800);
Selenium W3C Example:
Copy code
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "maxduration" : 1800
  }
}
Copy code
ChromeOptions chromeOpts = new ChromeOptions();
chromeOpts.setExperimentalOption("w3c", true);

MutableCapabilities tbOptions = new MutableCapabilities();
tbOptions.setCapability("key", "api_key");
tbOptions.setCapability("secret", "api_secret");
tbOptions.setCapability("maxduration", 1800);

DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(ChromeOptions.CAPABILITY, chromeOpts);
caps.setCapability("platformName", "Windows 10");
caps.setCapability("tb:options", tbOptions);
caps.setCapability("browserName", "chrome");
Copy code
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'maxduration' => 1800
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
Copy code
tbOptions = {
	'maxduration': 1800
}

chromeOpts =  {
    'browserName': "chrome",
    'platformName': "Windows 10",
    'goog:chromeOptions': {'w3c': True},
    'tb:options': tbOptions
}

self.driver = webdriver.Remote(remote_url, desired_capabilities=chromeOpts)
Copy code
driver = await new webdriver.Builder().withCapabilities({
    "browserName": 'chrome',
    "platformName": 'Windows 10',
    /** Google requires "w3c" to be set in "goog:chromeOptions" as true if you're using ChromeDriver version 74 or lower.
     * Based on this commit: https://chromium.googlesource.com/chromium/src/+/2b49880e2481658e0702fd6fe494859bca52b39c
     * ChromeDriver now uses w3c by default from version 75+ so setting this option will no longer be a requirement **/
    "goog:chromeOptions" : { "w3c" : true },
    "tb:options": {
        "key": "api_key",
        "secret": "api_secret",
        "maxduration": 1800
    }
}).usingServer("https://hub.testingbot.com/wd/hub").build();
Copy code
var chromeOptions = new ChromeOptions()
{
    BrowserVersion = "81",
    PlatformName = "Windows 10",
    UseSpecCompliantProtocol = true
};
var tbOptions = new Dictionary<string, object>
{
    ["key"] = "api_key",
    ["secret"] = "api_secret",
    ["maxduration"] = 1800
};

chromeOptions.AddAdditionalCapability("tb:options", tbOptions, true);

driver = new RemoteWebDriver(new Uri("https://hub.testingbot.com/wd/hub"),
    chromeOptions.ToCapabilities(), TimeSpan.FromSeconds(600));
Value Type Default Value
int (specify number of seconds) 1800 seconds (30 minutes)

Custom Metadata

Send along custom data, for example your release, server, commit hash, ...
This will show up on the test detail page in the TestingBot member area.

Copy code
caps = Selenium::WebDriver::Remote::Capabilities.new
caps["extra"] = "Extra Information"
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("extra", "Extra Information");
Copy code
$caps = array(
  "extra" => "Extra Information"
);
Copy code
capabilities = {
  "extra" : "Extra Information"
}
Copy code
const capabilities = {
  "extra" : "Extra Information"
}
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("extra", "Extra Information");
Selenium W3C Example:
Copy code
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "extra" : "Extra Information"
  }
}
Copy code
ChromeOptions chromeOpts = new ChromeOptions();
chromeOpts.setExperimentalOption("w3c", true);

MutableCapabilities tbOptions = new MutableCapabilities();
tbOptions.setCapability("key", "api_key");
tbOptions.setCapability("secret", "api_secret");
tbOptions.setCapability("extra", "Extra Information");

DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(ChromeOptions.CAPABILITY, chromeOpts);
caps.setCapability("platformName", "Windows 10");
caps.setCapability("tb:options", tbOptions);
caps.setCapability("browserName", "chrome");
Copy code
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'extra' => "Extra Information"
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
Copy code
tbOptions = {
	'extra': "Extra Information"
}

chromeOpts =  {
    'browserName': "chrome",
    'platformName': "Windows 10",
    'goog:chromeOptions': {'w3c': True},
    'tb:options': tbOptions
}

self.driver = webdriver.Remote(remote_url, desired_capabilities=chromeOpts)
Copy code
driver = await new webdriver.Builder().withCapabilities({
    "browserName": 'chrome',
    "platformName": 'Windows 10',
    /** Google requires "w3c" to be set in "goog:chromeOptions" as true if you're using ChromeDriver version 74 or lower.
     * Based on this commit: https://chromium.googlesource.com/chromium/src/+/2b49880e2481658e0702fd6fe494859bca52b39c
     * ChromeDriver now uses w3c by default from version 75+ so setting this option will no longer be a requirement **/
    "goog:chromeOptions" : { "w3c" : true },
    "tb:options": {
        "key": "api_key",
        "secret": "api_secret",
        "extra": "Extra Information"
    }
}).usingServer("https://hub.testingbot.com/wd/hub").build();
Copy code
var chromeOptions = new ChromeOptions()
{
    BrowserVersion = "81",
    PlatformName = "Windows 10",
    UseSpecCompliantProtocol = true
};
var tbOptions = new Dictionary<string, object>
{
    ["key"] = "api_key",
    ["secret"] = "api_secret",
    ["extra"] = "Extra Information"
};

chromeOptions.AddAdditionalCapability("tb:options", tbOptions, true);

driver = new RemoteWebDriver(new Uri("https://hub.testingbot.com/wd/hub"),
    chromeOptions.ToCapabilities(), TimeSpan.FromSeconds(600));
Value Type
string

Load custom browser extensions

If you specify this desired capability with the URL to your Chrome extension's .crx file or Firefox addon's .xpi file, we will download the extension, which will be added to Chrome or Firefox before your test starts.

Copy code
caps = Selenium::WebDriver::Remote::Capabilities.new
caps["load-extension"] = "https://..."
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("load-extension", "https://...");
Copy code
$caps = array(
  "load-extension" => "https://..."
);
Copy code
capabilities = {
  "load-extension" : "https://..."
}
Copy code
const capabilities = {
  "load-extension" : "https://..."
}
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("load-extension", "https://...");
Selenium W3C Example:
Copy code
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "load-extension" : "https://..."
  }
}
Copy code
ChromeOptions chromeOpts = new ChromeOptions();
chromeOpts.setExperimentalOption("w3c", true);

MutableCapabilities tbOptions = new MutableCapabilities();
tbOptions.setCapability("key", "api_key");
tbOptions.setCapability("secret", "api_secret");
tbOptions.setCapability("load-extension", "https://...");

DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(ChromeOptions.CAPABILITY, chromeOpts);
caps.setCapability("platformName", "Windows 10");
caps.setCapability("tb:options", tbOptions);
caps.setCapability("browserName", "chrome");
Copy code
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'load-extension' => "https://..."
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
Copy code
tbOptions = {
	'load-extension': "https://..."
}

chromeOpts =  {
    'browserName': "chrome",
    'platformName': "Windows 10",
    'goog:chromeOptions': {'w3c': True},
    'tb:options': tbOptions
}

self.driver = webdriver.Remote(remote_url, desired_capabilities=chromeOpts)
Copy code
driver = await new webdriver.Builder().withCapabilities({
    "browserName": 'chrome',
    "platformName": 'Windows 10',
    /** Google requires "w3c" to be set in "goog:chromeOptions" as true if you're using ChromeDriver version 74 or lower.
     * Based on this commit: https://chromium.googlesource.com/chromium/src/+/2b49880e2481658e0702fd6fe494859bca52b39c
     * ChromeDriver now uses w3c by default from version 75+ so setting this option will no longer be a requirement **/
    "goog:chromeOptions" : { "w3c" : true },
    "tb:options": {
        "key": "api_key",
        "secret": "api_secret",
        "load-extension": "https://..."
    }
}).usingServer("https://hub.testingbot.com/wd/hub").build();
Copy code
var chromeOptions = new ChromeOptions()
{
    BrowserVersion = "81",
    PlatformName = "Windows 10",
    UseSpecCompliantProtocol = true
};
var tbOptions = new Dictionary<string, object>
{
    ["key"] = "api_key",
    ["secret"] = "api_secret",
    ["load-extension"] = "https://..."
};

chromeOptions.AddAdditionalCapability("tb:options", tbOptions, true);

driver = new RemoteWebDriver(new Uri("https://hub.testingbot.com/wd/hub"),
    chromeOptions.ToCapabilities(), TimeSpan.FromSeconds(600));
Browser Supported Format Example
Chrome .zip file, containing the extension source code (manifest.json, src/ directory, ...) https://.../extension.zip
Firefox (Firefox-Unbranded) .zip file, containing the extension source code (manifest.json, src/ directory, lib/ directory, ...) https://.../extension.zip
Edge .zip file, containing the extension source code (manifest.json, src/ directory, ...) https://.../extension.zip
Safari (and Safari Technology Preview) .safariextz file https://.../extension.safariextz

With TestingBot Storage, you can upload your executable on our servers.
The advantage of this is that our test VMs can immediately download your executable from our own network, which is much faster than downloading from the public internet.
Once the file is uploaded via TestingBot Storage, you can use "prerun" : "tb://..."

Grouping

Specify in which groups you want to see the test results. You can group results to have an easy overview of tests across projects.

Copy code
caps = Selenium::WebDriver::Remote::Capabilities.new
caps["groups"] = "group1,group2"
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("groups", "group1,group2");
Copy code
$caps = array(
  "groups" => "group1,group2"
);
Copy code
capabilities = {
  "groups" : "group1,group2"
}
Copy code
const capabilities = {
  "groups" : "group1,group2"
}
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("groups", "group1,group2");
Selenium W3C Example:
Copy code
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "groups" : "group1,group2"
  }
}
Copy code
ChromeOptions chromeOpts = new ChromeOptions();
chromeOpts.setExperimentalOption("w3c", true);

MutableCapabilities tbOptions = new MutableCapabilities();
tbOptions.setCapability("key", "api_key");
tbOptions.setCapability("secret", "api_secret");
tbOptions.setCapability("groups", "group1,group2");

DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(ChromeOptions.CAPABILITY, chromeOpts);
caps.setCapability("platformName", "Windows 10");
caps.setCapability("tb:options", tbOptions);
caps.setCapability("browserName", "chrome");
Copy code
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'groups' => "group1,group2"
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
Copy code
tbOptions = {
	'groups': "group1,group2"
}

chromeOpts =  {
    'browserName': "chrome",
    'platformName': "Windows 10",
    'goog:chromeOptions': {'w3c': True},
    'tb:options': tbOptions
}

self.driver = webdriver.Remote(remote_url, desired_capabilities=chromeOpts)
Copy code
driver = await new webdriver.Builder().withCapabilities({
    "browserName": 'chrome',
    "platformName": 'Windows 10',
    /** Google requires "w3c" to be set in "goog:chromeOptions" as true if you're using ChromeDriver version 74 or lower.
     * Based on this commit: https://chromium.googlesource.com/chromium/src/+/2b49880e2481658e0702fd6fe494859bca52b39c
     * ChromeDriver now uses w3c by default from version 75+ so setting this option will no longer be a requirement **/
    "goog:chromeOptions" : { "w3c" : true },
    "tb:options": {
        "key": "api_key",
        "secret": "api_secret",
        "groups": "group1,group2"
    }
}).usingServer("https://hub.testingbot.com/wd/hub").build();
Copy code
var chromeOptions = new ChromeOptions()
{
    BrowserVersion = "81",
    PlatformName = "Windows 10",
    UseSpecCompliantProtocol = true
};
var tbOptions = new Dictionary<string, object>
{
    ["key"] = "api_key",
    ["secret"] = "api_secret",
    ["groups"] = "group1,group2"
};

chromeOptions.AddAdditionalCapability("tb:options", tbOptions, true);

driver = new RemoteWebDriver(new Uri("https://hub.testingbot.com/wd/hub"),
    chromeOptions.ToCapabilities(), TimeSpan.FromSeconds(600));
Value Type
string (comma-separated)

AutoClicker

Specify one or more of the possible options below to have TestingBot automatically click certain dialogs which are unable to be automated via Selenium WebDriver.

Copy code
caps = Selenium::WebDriver::Remote::Capabilities.new
caps["autoclick"] = []
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("autoclick", []);
Copy code
$caps = array(
  "autoclick" => []
);
Copy code
capabilities = {
  "autoclick" : []
}
Copy code
const capabilities = {
  "autoclick" : []
}
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("autoclick", []);
Selenium W3C Example:
Copy code
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "autoclick" : []
  }
}
Copy code
ChromeOptions chromeOpts = new ChromeOptions();
chromeOpts.setExperimentalOption("w3c", true);

MutableCapabilities tbOptions = new MutableCapabilities();
tbOptions.setCapability("key", "api_key");
tbOptions.setCapability("secret", "api_secret");
tbOptions.setCapability("autoclick", []);

DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(ChromeOptions.CAPABILITY, chromeOpts);
caps.setCapability("platformName", "Windows 10");
caps.setCapability("tb:options", tbOptions);
caps.setCapability("browserName", "chrome");
Copy code
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'autoclick' => []
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
Copy code
tbOptions = {
	'autoclick': []
}

chromeOpts =  {
    'browserName': "chrome",
    'platformName': "Windows 10",
    'goog:chromeOptions': {'w3c': True},
    'tb:options': tbOptions
}

self.driver = webdriver.Remote(remote_url, desired_capabilities=chromeOpts)
Copy code
driver = await new webdriver.Builder().withCapabilities({
    "browserName": 'chrome',
    "platformName": 'Windows 10',
    /** Google requires "w3c" to be set in "goog:chromeOptions" as true if you're using ChromeDriver version 74 or lower.
     * Based on this commit: https://chromium.googlesource.com/chromium/src/+/2b49880e2481658e0702fd6fe494859bca52b39c
     * ChromeDriver now uses w3c by default from version 75+ so setting this option will no longer be a requirement **/
    "goog:chromeOptions" : { "w3c" : true },
    "tb:options": {
        "key": "api_key",
        "secret": "api_secret",
        "autoclick": []
    }
}).usingServer("https://hub.testingbot.com/wd/hub").build();
Copy code
var chromeOptions = new ChromeOptions()
{
    BrowserVersion = "81",
    PlatformName = "Windows 10",
    UseSpecCompliantProtocol = true
};
var tbOptions = new Dictionary<string, object>
{
    ["key"] = "api_key",
    ["secret"] = "api_secret",
    ["autoclick"] = []
};

chromeOptions.AddAdditionalCapability("tb:options", tbOptions, true);

driver = new RemoteWebDriver(new Uri("https://hub.testingbot.com/wd/hub"),
    chromeOptions.ToCapabilities(), TimeSpan.FromSeconds(600));
Value Type Possible Values:
array of options chrome_extension_add, chrome_extension_permissions_allow

Sikuli

Specify an URL to a zip-file containing one or more .sikulu projects. These will automatically start before your test runs, so that you can do certain automated tasks which Selenium cannot do (clicking native dialogs, ...)

Find more information regarding Sikuli Cloud Testing.

Copy code
caps = Selenium::WebDriver::Remote::Capabilities.new
caps["sikuli"] = "https://..."
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("sikuli", "https://...");
Copy code
$caps = array(
  "sikuli" => "https://..."
);
Copy code
capabilities = {
  "sikuli" : "https://..."
}
Copy code
const capabilities = {
  "sikuli" : "https://..."
}
Copy code
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("sikuli", "https://...");
Selenium W3C Example:
Copy code
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "sikuli" : []
  }
}
Copy code
ChromeOptions chromeOpts = new ChromeOptions();
chromeOpts.setExperimentalOption("w3c", true);

MutableCapabilities tbOptions = new MutableCapabilities();
tbOptions.setCapability("key", "api_key");
tbOptions.setCapability("secret", "api_secret");
tbOptions.setCapability("sikuli", []);

DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(ChromeOptions.CAPABILITY, chromeOpts);
caps.setCapability("platformName", "Windows 10");
caps.setCapability("tb:options", tbOptions);
caps.setCapability("browserName", "chrome");
Copy code
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'sikuli' => []
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
Copy code
tbOptions = {
	'sikuli': []
}

chromeOpts =  {
    'browserName': "chrome",
    'platformName': "Windows 10",
    'goog:chromeOptions': {'w3c': True},
    'tb:options': tbOptions
}

self.driver = webdriver.Remote(remote_url, desired_capabilities=chromeOpts)
Copy code
driver = await new webdriver.Builder().withCapabilities({
    "browserName": 'chrome',
    "platformName": 'Windows 10',
    /** Google requires "w3c" to be set in "goog:chromeOptions" as true if you're using ChromeDriver version 74 or lower.
     * Based on this commit: https://chromium.googlesource.com/chromium/src/+/2b49880e2481658e0702fd6fe494859bca52b39c
     * ChromeDriver now uses w3c by default from version 75+ so setting this option will no longer be a requirement **/
    "goog:chromeOptions" : { "w3c" : true },
    "tb:options": {
        "key": "api_key",
        "secret": "api_secret",
        "sikuli": []
    }
}).usingServer("https://hub.testingbot.com/wd/hub").build();
Copy code
var chromeOptions = new ChromeOptions()
{
    BrowserVersion = "81",
    PlatformName = "Windows 10",
    UseSpecCompliantProtocol = true
};
var tbOptions = new Dictionary<string, object>
{
    ["key"] = "api_key",
    ["secret"] = "api_secret",
    ["sikuli"] = []
};

chromeOptions.AddAdditionalCapability("tb:options", tbOptions, true);

driver = new RemoteWebDriver(new Uri("https://hub.testingbot.com/wd/hub"),
    chromeOptions.ToCapabilities(), TimeSpan.FromSeconds(600));
Value Type
string (URL to zipped Sikuli project)