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

Selenium Test Options

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 = {
  browser_name: "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 = {
  browser_name: "chrome",
  browser_version: "81"
}
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.

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));

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 = {
  platform_name: "Windows 10",
  browser_name: "chrome",
  browser_version: "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.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.


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 = {
  platform_name: "Windows 10",
  browser_name: "chrome",
  browser_version: "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 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 = {
  platform_name: "Windows 10",
  browser_name: "chrome",
  browser_version: "latest",
  "tb:options" => {
    "iedriverVersion" : "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("iedriverVersion", "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(
	'iedriverVersion' => "2.53.1"
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
tbOptions = {
	'name': 'W3C Sample',
	'iedriverVersion': "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",
        "iedriverVersion": "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",
    ["iedriverVersion"] = "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
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 = Selenium::WebDriver::Remote::Capabilities.new
caps["edgedriverVersion"] = "87"
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("edgedriverVersion", "87");
$caps = array(
  "edgedriverVersion" => "87"
);
capabilities = {
  "edgedriverVersion" : "87"
}
const capabilities = {
  "edgedriverVersion" : "87"
}
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("edgedriverVersion", "87");

Selenium W3C Example:

caps = {
  platform_name: "Windows 10",
  browser_name: "chrome",
  browser_version: "latest",
  "tb:options" => {
    "edgedriverVersion" : "87"
  }
}
ChromeOptions chromeOpts = new ChromeOptions();
chromeOpts.setExperimentalOption("w3c", true);

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

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(
	'edgedriverVersion' => "87"
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
tbOptions = {
	'name': 'W3C Sample',
	'edgedriverVersion': "87"
}

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",
        "edgedriverVersion": "87"
    }
}).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",
    ["edgedriverVersion"] = "87"
};

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 15063
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 = {
  platform_name: "Windows 10",
  browser_name: "chrome",
  browser_version: "latest",
  "tb:options" => {
    "geckodriverVersion" : "0.28.0"
  }
}
ChromeOptions chromeOpts = new ChromeOptions();
chromeOpts.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(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(
	'geckodriverVersion' => "0.28.0"
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
tbOptions = {
	'name': 'W3C Sample',
	'geckodriverVersion': "0.28.0"
}

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",
        "geckodriverVersion": "0.28.0"
    }
}).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",
    ["geckodriverVersion"] = "0.28.0"
};

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 0.28.0
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 = {
  platform_name: "Windows 10",
  browser_name: "chrome",
  browser_version: "latest",
  "tb:options" => {
    "operaDriverVersion" : "90.0.4430.85"
  }
}
ChromeOptions chromeOpts = new ChromeOptions();
chromeOpts.setExperimentalOption("w3c", true);

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(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(
	'operaDriverVersion' => "90.0.4430.85"
));
$capabilities->setCapability(ChromeOptions::CAPABILITY, $options);
tbOptions = {
	'name': 'W3C Sample',
	'operaDriverVersion': "90.0.4430.85"
}

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",
        "operaDriverVersion": "90.0.4430.85"
    }
}).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",
    ["operaDriverVersion"] = "90.0.4430.85"
};

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 87.0.4280.67
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 = {
  platform_name: "Windows 10",
  browser_name: "chrome",
  browser_version: "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 = {
  platform_name: "Windows 10",
  browser_name: "chrome",
  browser_version: "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 = {
  platform_name: "Windows 10",
  browser_name: "chrome",
  browser_version: "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 = {
  platform_name: "Windows 10",
  browser_name: "chrome",
  browser_version: "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 = {
  platform_name: "Windows 10",
  browser_name: "chrome",
  browser_version: "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 = {
  platform_name: "Windows 10",
  browser_name: "chrome",
  browser_version: "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 = {
  platform_name: "Windows 10",
  browser_name: "chrome",
  browser_version: "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 = {
  platform_name: "Windows 10",
  browser_name: "chrome",
  browser_version: "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 = {
  platform_name: "Windows 10",
  browser_name: "chrome",
  browser_version: "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 = {
  platform_name: "Windows 10",
  browser_name: "chrome",
  browser_version: "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/").

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


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 = {
  platform_name: "Windows 10",
  browser_name: "chrome",
  browser_version: "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 = {
  platform_name: "Windows 10",
  browser_name: "chrome",
  browser_version: "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:


  • 'AU': Australia
  • 'BE': Belgium
  • 'CN': China
  • 'FR': France
  • 'DE': Germany
  • 'IT': Italy
  • 'JP': Japan
  • 'ES': Spain
  • '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 = {
  platform_name: "Windows 10",
  browser_name: "chrome",
  browser_version: "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 = {
  platform_name: "Windows 10",
  browser_name: "chrome",
  browser_version: "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 = {
  platform_name: "Windows 10",
  browser_name: "chrome",
  browser_version: "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 = {
  platform_name: "Windows 10",
  browser_name: "chrome",
  browser_version: "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 = {
  platform_name: "Windows 10",
  browser_name: "chrome",
  browser_version: "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 = {
  platform_name: "Windows 10",
  browser_name: "chrome",
  browser_version: "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 = {
  platform_name: "Windows 10",
  browser_name: "chrome",
  browser_version: "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: