Features

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.

caps = Selenium::WebDriver::Remote::Capabilities.new
caps["browserName"] = "chrome"
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("browserName", "chrome");
$caps = array(
  "browserName" => "chrome"
);
capabilities = {
  "browserName" : "chrome"
}
const capabilities = {
  "browserName" : "chrome"
}
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("browserName", "chrome");
Selenium W3C Example:
caps = {
  browserName: "chrome"
}
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");
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
tbOptions = {
	'name': 'W3C Sample'
}

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

self.driver = webdriver.Remote(remote_url, desired_capabilities=chromeOpts)
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();
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.

caps = Selenium::WebDriver::Remote::Capabilities.new
caps["version"] = "81"
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("version", "81");
$caps = array(
  "version" => "81"
);
capabilities = {
  "version" : "81"
}
const capabilities = {
	 "version" : "81"
}
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("version", "81");
Selenium W3C Example:
caps = {
  browserName: "chrome",
  browserVersion: "106"
}
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");
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setVersion(81);
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
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)
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();
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.

caps = Selenium::WebDriver::Remote::Capabilities.new
caps["platform"] = "Windows 10"
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("platform", "Windows 10");
$caps = array(
  "platform" => "Windows 10"
);
capabilities = {
  "platform" : "Windows 10"
}
const capabilities = {
	 "platform" : "Windows 10"
}
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("platform", "Windows 10");
Selenium W3C Example:
caps = {
  platform_name: "Windows 10"	
}
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");
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
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)
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();
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.

caps = {
  deviceName: "Samsung S21"	
}
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");
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)
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();
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:

// 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.

caps = {
  version: "(16|17).*"	
}
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).*");
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)
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();
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:

// 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.

caps = {
  deviceName: "*",
  tabletOnly: true
}
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);
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)
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();
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.

caps = {
  deviceName: "*",
  phoneOnly: true
}
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);
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)
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();
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:

caps = Selenium::WebDriver::Remote::Capabilities.new
caps["selenium-version"] = '2.53.1'
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("selenium-version", '2.53.1');
$caps = array(
  "selenium-version" => '2.53.1'
);
capabilities = {
  "selenium-version" : '2.53.1'
}
const capabilities = {
  "selenium-version" : '2.53.1'
}
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("selenium-version", '2.53.1');
Selenium W3C Example:
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "selenium-version" : '2.53.1'
  }
}
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");
$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);
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)
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();
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.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.

caps = Selenium::WebDriver::Remote::Capabilities.new
caps["chromedriverVersion"] = "76.0.3809.25"
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("chromedriverVersion", "76.0.3809.25");
$caps = array(
  "chromedriverVersion" => "76.0.3809.25"
);
capabilities = {
  "chromedriverVersion" : "76.0.3809.25"
}
const capabilities = {
  "chromedriverVersion" : "76.0.3809.25"
}
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("chromedriverVersion", "76.0.3809.25");
Selenium W3C Example:
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "chromedriverVersion" : "76.0.3809.25"
  }
}
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");
$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);
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)
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();
var chromeOptions = new ChromeOptions()
{
    BrowserVersion = "81",
    PlatformName = "Windows 10",
    UseSpecCompliantProtocol = true
};
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 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.

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

caps = {
	"browserName" : "MicrosoftEdge",
	"platform": "WINDOWS"
}
caps["edgedriverVersion"] = "110"
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("edgedriverVersion", "110");
$caps = array(
  "edgedriverVersion" => "110"
);
capabilities = {
  "edgedriverVersion" : "110"
}
const capabilities = {
  "edgedriverVersion" : "110",
  "ms:edgeOptions": {}
}
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:
caps = {
  platformName: "Windows 10",
  browserName: "microsoftedge",
  browserVersion: "latest",
  "tb:options" => {
    "edgedriverVersion" : "110"
  },
  "ms:edgeOptions": {}
}
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");
$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);
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)
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();
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
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.

caps = Selenium::WebDriver::Remote::Capabilities.new
caps["geckodriverVersion"] = "0.28.0"
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("geckodriverVersion", "0.28.0");
$caps = array(
  "geckodriverVersion" => "0.28.0"
);
capabilities = {
  "geckodriverVersion" : "0.28.0"
}
const capabilities = {
  "geckodriverVersion" : "0.28.0"
}
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("geckodriverVersion", "0.28.0");
Selenium W3C Example:
caps = {
  platformName: "Windows 10",
  browserName: "firefox",
  browserVersion: "latest",
  "tb:options": {
    "geckodriverVersion" : "0.28.0"
  },
  "moz:firefoxOptions": {}
}
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");
$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);
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)
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();
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.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.

caps = Selenium::WebDriver::Remote::Capabilities.new
caps["operaDriverVersion"] = "90.0.4430.85"
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("operaDriverVersion", "90.0.4430.85");
$caps = array(
  "operaDriverVersion" => "90.0.4430.85"
);
capabilities = {
  "operaDriverVersion" : "90.0.4430.85"
}
const capabilities = {
  "operaDriverVersion" : "90.0.4430.85"
}
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("operaDriverVersion", "90.0.4430.85");
Selenium W3C Example:
caps = {
  platformName: "Windows 10",
  browserName: "opera",
  browserVersion: "latest",
  "tb:options" => {
    "operaDriverVersion" : "90.0.4430.85"
  }
}
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");
$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);
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)
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();
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
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.

caps = Selenium::WebDriver::Remote::Capabilities.new
caps["screenshot"] = true
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("screenshot", true);
$caps = array(
  "screenshot" => true
);
capabilities = {
  "screenshot" : True
}
const capabilities = {
  "screenshot" : true
}
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("screenshot", true);
Selenium W3C Example:
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    screenshot: true
  }
}
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");
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'screenshot' => true
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
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)
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();
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.

caps = Selenium::WebDriver::Remote::Capabilities.new
caps["screenrecorder"] = true
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("screenrecorder", true);
$caps = array(
  "screenrecorder" => true
);
capabilities = {
  "screenrecorder" : True
}
const capabilities = {
  "screenrecorder" : true
}
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("screenrecorder", true);
Selenium W3C Example:
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    screenrecorder: true
  }
}
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");
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'screenrecorder' => true
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
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)
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();
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.

caps = Selenium::WebDriver::Remote::Capabilities.new
caps["public"] = false
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("public", false);
$caps = array(
  "public" => false
);
capabilities = {
  "public" : False
}
const capabilities = {
  "public" : false
}
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("public", false);
Selenium W3C Example:
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "public" : false
  }
}
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");
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'public' => 130
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
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)
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();
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.

caps = Selenium::WebDriver::Remote::Capabilities.new
caps["blacklist"] = "site1.com,site2.com"
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("blacklist", "site1.com,site2.com");
$caps = array(
  "blacklist" => "site1.com,site2.com"
);
capabilities = {
  "blacklist" : "site1.com,site2.com"
}
const capabilities = {
  "blacklist" : "site1.com,site2.com"
}
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("blacklist", "site1.com,site2.com");
Selenium W3C Example:
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "blacklist" : "site1.com,site2.com"
  }
}
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");
$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);
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)
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();
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, ...).

caps = Selenium::WebDriver::Remote::Capabilities.new
caps["recordLogs"] = true
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("recordLogs", true);
$caps = array(
  "recordLogs" => true
);
capabilities = {
  "recordLogs" : True
}
const capabilities = {
  "recordLogs" : true
}
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("recordLogs", true);
Selenium W3C Example:
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "recordLogs" : true
  }
}
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");
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'recordLogs' => true
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
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)
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();
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:

caps = Selenium::WebDriver::Remote::Capabilities.new
caps["timeZone"] = "Etc/UTC"
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("timeZone", "Etc/UTC");
$caps = array(
  "timeZone" => "Etc/UTC"
);
capabilities = {
  "timeZone" : "Etc/UTC"
}
const capabilities = {
  "timeZone" : "Etc/UTC"
}
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("timeZone", "Etc/UTC");
Selenium W3C Example:
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "timeZone" : "Etc/UTC"
  }
}
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");
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'timeZone' => "Etc/UTC"
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
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)
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();
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.

caps = Selenium::WebDriver::Remote::Capabilities.new
caps["screen-resolution"] = "1280x1024"
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("screen-resolution", "1280x1024");
$caps = array(
  "screen-resolution" => "1280x1024"
);
capabilities = {
  "screen-resolution" : "1280x1024"
}
const capabilities = {
  "screen-resolution" : "1280x1024"
}
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("screen-resolution", "1280x1024");
Selenium W3C Example:
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "screen-resolution" : "1280x1024"
  }
}
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");
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'screen-resolution' => "1280x1024"
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
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)
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();
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.

caps = Selenium::WebDriver::Remote::Capabilities.new
caps["prerun"] = "https://..."
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("prerun", "https://...");
$caps = array(
  "prerun" => "https://..."
);
capabilities = {
  "prerun" : "https://..."
}
const capabilities = {
  "prerun" : "https://..."
}
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("prerun", "https://...");
Selenium W3C Example:
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "prerun" : "https://..."
  }
}
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");
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'prerun' => "https://..."
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
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)
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();
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)
"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.

caps = Selenium::WebDriver::Remote::Capabilities.new
caps["hosts"] = [{ ip: '127.0.0.1', domain: 'mydomain' }]
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("hosts", [{ ip: '127.0.0.1', domain: 'mydomain' }]);
$caps = array(
  "hosts" => [{ ip: '127.0.0.1', domain: 'mydomain' }]
);
capabilities = {
  "hosts" : [{ ip: '127.0.0.1', domain: 'mydomain' }]
}
const capabilities = {
  "hosts" : [{ ip: '127.0.0.1', domain: 'mydomain' }]
}
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("hosts", [{ ip: '127.0.0.1', domain: 'mydomain' }]);
Selenium W3C Example:
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "hosts" : [{ ip: '127.0.0.1', domain: 'mydomain' }]
  }
}
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");
$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);
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)
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();
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.

caps = Selenium::WebDriver::Remote::Capabilities.new
caps["upload"] = "https://..."
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("upload", "https://...");
$caps = array(
  "upload" => "https://..."
);
capabilities = {
  "upload" : "https://..."
}
const capabilities = {
  "upload" : "https://..."
}
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("upload", "https://...");
Selenium W3C Example:
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "upload" : "https://..."
  }
}
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");
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'upload' => "https://..."
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
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)
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();
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:
"uploadFilepath" : "C:\\test\\myfile.ext"
Example (Selenium 4):
"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

caps = Selenium::WebDriver::Remote::Capabilities.new
caps["uploadMultiple"] = [{ url: "", filePath: "" }]
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("uploadMultiple", [{ url: "", filePath: "" }]);
$caps = array(
  "uploadMultiple" => [{ url: "", filePath: "" }]
);
capabilities = {
  "uploadMultiple" : [{ url: "", filePath: "" }]
}
const capabilities = {
  "uploadMultiple" : [{ url: "", filePath: "" }]
}
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("uploadMultiple", [{ url: "", filePath: "" }]);
Selenium W3C Example:
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "uploadMultiple" : [{ url: "", filePath: "" }]
  }
}
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");
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'uploadMultiple' => [{ url: "", filePath: "" }]
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
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)
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();
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.

caps = Selenium::WebDriver::Remote::Capabilities.new
caps["testingbot.geoCountryCode"] = "DE"
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("testingbot.geoCountryCode", "DE");
$caps = array(
  "testingbot.geoCountryCode" => "DE"
);
capabilities = {
  "testingbot.geoCountryCode" : "DE"
}
const capabilities = {
  "testingbot.geoCountryCode" : "DE"
}
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("testingbot.geoCountryCode", "DE");
Selenium W3C Example:
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "testingbot.geoCountryCode" : "DE"
  }
}
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");
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'testingbot.geoCountryCode' => "DE"
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
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)
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();
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
  • 'CO': Colombia
  • 'EG': Egypt
  • '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.

caps = Selenium::WebDriver::Remote::Capabilities.new
caps["name"] = "My Test Name"
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("name", "My Test Name");
$caps = array(
  "name" => "My Test Name"
);
capabilities = {
  "name" : "My Test Name"
}
const capabilities = {
  "name" : "My Test Name"
}
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("name", "My Test Name");
Selenium W3C Example:
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "name" : "My Test Name"
  }
}
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");
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'name' => "My Test Name"
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
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)
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();
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.

caps = Selenium::WebDriver::Remote::Capabilities.new
caps["build"] = "My First Build"
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("build", "My First Build");
$caps = array(
  "build" => "My First Build"
);
capabilities = {
  "build" : "My First Build"
}
const capabilities = {
  "build" : "My First Build"
}
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("build", "My First Build");
Selenium W3C Example:
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "build" : "My First Build"
  }
}
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");
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'build' => "My First Build"
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
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)
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();
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.

caps = Selenium::WebDriver::Remote::Capabilities.new
caps["idletimeout"] = 130
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("idletimeout", 130);
$caps = array(
  "idletimeout" => 130
);
capabilities = {
  "idletimeout" : 130
}
const capabilities = {
  "idletimeout" : 130
}
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("idletimeout", 130);
Selenium W3C Example:
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "idletimeout" : 130
  }
}
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");
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'idletimeout' => 130
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
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)
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();
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.

caps = Selenium::WebDriver::Remote::Capabilities.new
caps["maxduration"] = 1800
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("maxduration", 1800);
$caps = array(
  "maxduration" => 1800
);
capabilities = {
  "maxduration" : 1800
}
const capabilities = {
  "maxduration" : 1800
}
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("maxduration", 1800);
Selenium W3C Example:
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "maxduration" : 1800
  }
}
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");
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'maxduration' => 1800
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
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)
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();
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.

caps = Selenium::WebDriver::Remote::Capabilities.new
caps["extra"] = "Extra Information"
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("extra", "Extra Information");
$caps = array(
  "extra" => "Extra Information"
);
capabilities = {
  "extra" : "Extra Information"
}
const capabilities = {
  "extra" : "Extra Information"
}
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("extra", "Extra Information");
Selenium W3C Example:
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "extra" : "Extra Information"
  }
}
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");
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'extra' => "Extra Information"
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
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)
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();
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.

caps = Selenium::WebDriver::Remote::Capabilities.new
caps["load-extension"] = "https://..."
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("load-extension", "https://...");
$caps = array(
  "load-extension" => "https://..."
);
capabilities = {
  "load-extension" : "https://..."
}
const capabilities = {
  "load-extension" : "https://..."
}
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("load-extension", "https://...");
Selenium W3C Example:
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "load-extension" : "https://..."
  }
}
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");
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'load-extension' => "https://..."
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
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)
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();
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.

caps = Selenium::WebDriver::Remote::Capabilities.new
caps["groups"] = "group1,group2"
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("groups", "group1,group2");
$caps = array(
  "groups" => "group1,group2"
);
capabilities = {
  "groups" : "group1,group2"
}
const capabilities = {
  "groups" : "group1,group2"
}
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("groups", "group1,group2");
Selenium W3C Example:
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "groups" : "group1,group2"
  }
}
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");
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'groups' => "group1,group2"
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
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)
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();
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.

caps = Selenium::WebDriver::Remote::Capabilities.new
caps["autoclick"] = []
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("autoclick", []);
$caps = array(
  "autoclick" => []
);
capabilities = {
  "autoclick" : []
}
const capabilities = {
  "autoclick" : []
}
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("autoclick", []);
Selenium W3C Example:
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "autoclick" : []
  }
}
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");
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'autoclick' => []
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
tbOptions = {
	'autoclick': []
}

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

self.driver = webdriver.Remote(remote_url, desired_capabilities=chromeOpts)
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();
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.

caps = Selenium::WebDriver::Remote::Capabilities.new
caps["sikuli"] = "https://..."
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("sikuli", "https://...");
$caps = array(
  "sikuli" => "https://..."
);
capabilities = {
  "sikuli" : "https://..."
}
const capabilities = {
  "sikuli" : "https://..."
}
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("sikuli", "https://...");
Selenium W3C Example:
caps = {
  platformName: "Windows 10",
  browserName: "chrome",
  browserVersion: "latest",
  "tb:options" => {
    "sikuli" : []
  }
}
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");
$options = new ChromeOptions();
$capabilities = DesiredCapabilities::chrome();
$capabilities->setPlatform('Windows 10');
$capabilities->setCapability('tb:options', array(
	'sikuli' => []
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
tbOptions = {
	'sikuli': []
}

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

self.driver = webdriver.Remote(remote_url, desired_capabilities=chromeOpts)
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();
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)