What Are Desired Capabilities in Selenium Webdriver? Are They Depricated?

Capabilities for Different Browsers

Below is the per-browser pattern, written first in legacy Selenium 3 style and then in modern Selenium 4 style. New code should use the Selenium 4 patterns; the legacy snippets are included for engineers maintaining older suites.

Desired Capabilities in Selenium WebDriver for Chrome

Chrome capabilities are configured through ChromeOptions. In Selenium 3 you wrapped ChromeOptions inside a DesiredCapabilities object; in Selenium 4 you pass ChromeOptions directly.

Commonly used ChromeOptions arguments:

• --disable-infobars: Suppresses the "Chrome is being controlled by automated software" notification.
• --make-default-browser: Marks Chrome as the default browser.
• --disable-popup-blocking: Disables popups in Chrome.
• --incognito: Opens Chrome in incognito mode.
• --start-maximized: Opens Chrome maximized.
• --headless=new: Runs Chrome in the modern headless mode introduced in Chrome 109.

Selenium 3 pattern (deprecated) with an ad-blocker extension. Prerequisite: a .crx file of the extension downloaded locally.

// Selenium 3 - DesiredCapabilities (deprecated in Selenium 4)
ChromeOptions options = new ChromeOptions();
options.addExtensions(new File("path/to/extension.crx"));

DesiredCapabilities capabilities = new DesiredCapabilities();
capabilities.setCapability(ChromeOptions.CAPABILITY, options);

ChromeDriver driver = new ChromeDriver(capabilities);

Selenium 4 pattern (recommended) for the same scenario:

// Selenium 4 - ChromeOptions only, no DesiredCapabilities
ChromeOptions options = new ChromeOptions();
options.addExtensions(new File("path/to/extension.crx"));
options.addArguments("--start-maximized", "--disable-infobars");

ChromeDriver driver = new ChromeDriver(options);
driver.get("https://www.testmuai.com/selenium-playground/");

Desired Capabilities in Selenium WebDriver for Firefox

For Firefox, FirefoxOptions serializes to the moz:firefoxOptions vendor namespace. Use it to set binary path, command-line arguments, profile path, and preferences.

Common moz:firefoxOptions fields

• binary (string): Absolute path to a custom Firefox binary. By default GeckoDriver locates Firefox automatically.
• args (array of strings): Command-line arguments. Use leading hyphens, for example ["-headless", "-profile", "/path/to/profile"].
• profile (string): Path to a Firefox profile directory. For overriding individual preferences prefer the prefs map below instead of switching the whole profile.
• prefs (map): Override individual about:config preferences without changing the profile.

W3C JSON capabilities (Firefox)

{
  "capabilities": {
    "alwaysMatch": {
      "browserName": "firefox",
      "moz:firefoxOptions": {
        "binary": "/usr/local/firefox/bin/firefox",
        "args": ["-headless", "-profile", "/path/to/profile"],
        "prefs": {
          "dom.ipc.processCount": 9,
          "javascript.options.showInConsole": true
        },
        "log": { "level": "trace" }
      }
    }
  }
}

Selenium 4 Java equivalent

FirefoxOptions options = new FirefoxOptions();
options.addArguments("-headless");
options.addPreference("dom.ipc.processCount", 9);
options.addPreference("javascript.options.showInConsole", true);

WebDriver driver = new FirefoxDriver(options);

Desired Capabilities in Selenium WebDriver for Edge

Internet Explorer reached end of support on June 15, 2022, and is no longer the right target for new automation work. Microsoft Edge replaced it. Edge uses EdgeOptions, which serializes to the ms:edgeOptions vendor namespace and shares most of its surface area with ChromeOptions because Edge is Chromium-based.

Selenium 4 Java example for Edge

import org.openqa.selenium.edge.EdgeDriver;
import org.openqa.selenium.edge.EdgeOptions;

EdgeOptions options = new EdgeOptions();
options.setBrowserVersion("latest");
options.setPlatformName("Windows 11");
options.addArguments("--start-maximized", "--inprivate");

EdgeDriver driver = new EdgeDriver(options);
driver.get("https://www.testmuai.com/selenium-playground/");

If you maintain a legacy IE test suite, Microsoft documents an "IE mode" inside Edge that lets you run IE-only sites through Edge using the ie.edgechromium capability on InternetExplorerOptions, but greenfield work should target Edge directly.

Examples of Desired Capabilities in Selenium With Different Languages

Selenium ships official bindings for Java, C#, Python, JavaScript, and Ruby. Below is the same TestMu AI cloud-grid setup in Java, C#, and Python using Selenium 4 Options classes. Each example reads credentials from environment variables and groups grid-specific keys under the LT:Options vendor namespace.

Desired Capabilities in Selenium WebDriver for Java

import org.openqa.selenium.chrome.ChromeOptions;
import org.openqa.selenium.remote.RemoteWebDriver;

import java.net.URL;
import java.util.HashMap;

@BeforeClass
public void setUp() throws Exception {
    ChromeOptions options = new ChromeOptions();
    options.setBrowserVersion("latest");
    options.setPlatformName("Windows 11");

    HashMap<String, Object> ltOptions = new HashMap<>();
    ltOptions.put("username", System.getenv("LT_USERNAME"));
    ltOptions.put("accessKey", System.getenv("LT_ACCESS_KEY"));
    ltOptions.put("build", "Capabilities Demo");
    ltOptions.put("name", "Java Sample");
    ltOptions.put("network", true);
    ltOptions.put("visual", true);
    ltOptions.put("video", true);
    ltOptions.put("console", true);
    ltOptions.put("selenium_version", "4.27.0");
    ltOptions.put("timezone", "UTC+05:30");
    ltOptions.put("geoLocation", "IN");
    options.setCapability("LT:Options", ltOptions);

    driver = new RemoteWebDriver(
        new URL("https://hub.lambdatest.com/wd/hub"), options);
}

Desired Capabilities in Selenium WebDriver for C#

// Selenium 4 with C# - ChromeOptions, no DesiredCapabilities
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;
using OpenQA.Selenium.Remote;
using System;
using System.Collections.Generic;

ChromeOptions options = new ChromeOptions();
options.BrowserVersion = "latest";
options.PlatformName = "Windows 11";

// Accept self-signed certificates
options.AcceptInsecureCertificates = true;

// Add a Chrome extension
options.AddExtensions("path/to/extension.crx");

// Disable JavaScript at the profile level (Firefox example shown for parity)
// FirefoxOptions ffOptions = new FirefoxOptions();
// ffOptions.SetPreference("javascript.enabled", false);

// LT:Options vendor capability for the TestMu AI grid
Dictionary<string, object> ltOptions = new Dictionary<string, object>();
ltOptions.Add("username", Environment.GetEnvironmentVariable("LT_USERNAME"));
ltOptions.Add("accessKey", Environment.GetEnvironmentVariable("LT_ACCESS_KEY"));
ltOptions.Add("build", "Capabilities Demo");
ltOptions.Add("name", "C# Sample");
options.AddAdditionalOption("LT:Options", ltOptions);

IWebDriver driver = new RemoteWebDriver(
    new Uri("https://hub.lambdatest.com/wd/hub"), options);

Desired Capabilities in Selenium WebDriver for Python

# Selenium 4 with Python - Options class, no DesiredCapabilities
import os
from selenium import webdriver
from selenium.webdriver.chrome.options import Options as ChromeOptions

def build_driver(browser, browser_version, platform_name):
    options = ChromeOptions()
    options.browser_version = browser_version
    options.platform_name = platform_name

    lt_options = {
        "username": os.environ["LT_USERNAME"],
        "accessKey": os.environ["LT_ACCESS_KEY"],
        "build": "Capabilities Demo",
        "name": "Python Sample",
        "network": True,
        "video": True,
        "console": True,
    }
    options.set_capability("LT:Options", lt_options)

    return webdriver.Remote(
        command_executor="https://hub.lambdatest.com/wd/hub",
        options=options,
    )

driver = build_driver("chrome", "latest", "Windows 11")
driver.get("https://www.testmuai.com/selenium-playground/")
driver.quit()

Setting Selenium Capabilities with the TestMu AI Capabilities Generator

TestMu AI is a cloud-based cross-browser testing platform that lets you execute Selenium automation on an online Selenium Grid covering 3000+ browser and OS combinations, plus a separate real device cloud of 10,000+ iOS and Android devices for mobile work. Every Selenium-supported language and framework runs against the grid, including Java, C#, Python, JavaScript, and Ruby.

Writing capability blocks by hand for every browser plus OS combination is error prone, especially when migrating from the deprecated DesiredCapabilities pattern to Selenium 4 Options. The TestMu AI Capabilities Generator generates ready-to-paste capability snippets for multiple languages from a point-and-click selection.

Pick the browser, OS, version, Selenium version, and grid options you need; the generator produces the corresponding capability block. The Selenium 4 tab outputs Options-class snippets with vendor-prefixed keys (goog:chromeOptions, moz:firefoxOptions, LT:Options) so the result drops into a W3C-compliant Selenium 4 codebase without changes. Pair it with the TestMu AI integrations for CI/CD, project management, and collaboration tools to wire the generated config into your pipeline.

Full Example Script Incorporating Desired Capabilities

Below is an end-to-end TestNG sample using Selenium 4 ChromeOptions, parameterized over browser and version through TestNG, and pointed at the TestMu AI Selenium Grid.

package com.testmuai;

import org.openqa.selenium.By;
import org.openqa.selenium.JavascriptExecutor;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeOptions;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Parameters;
import org.testng.annotations.Test;

import java.net.URL;
import java.time.Duration;
import java.util.HashMap;

public class CapabilitiesDemoTest {

    public static RemoteWebDriver driver = null;
    private final String username = System.getenv("LT_USERNAME");
    private final String accessKey = System.getenv("LT_ACCESS_KEY");
    private final String gridUrl = "https://hub.lambdatest.com/wd/hub";
    boolean status = false;

    @Parameters(value = { "browser", "version" })
    @BeforeClass
    public void setUp(String browser, String version) throws Exception {
        ChromeOptions options = new ChromeOptions();
        options.setBrowserVersion(version);
        options.setPlatformName("Windows 11");

        HashMap<String, Object> ltOptions = new HashMap<>();
        ltOptions.put("username", username);
        ltOptions.put("accessKey", accessKey);
        ltOptions.put("build", "Capabilities Demo");
        ltOptions.put("name", "Selenium 4 Java Sample");
        ltOptions.put("network", true);
        ltOptions.put("visual", true);
        ltOptions.put("video", true);
        ltOptions.put("console", true);
        ltOptions.put("selenium_version", "4.27.0");
        ltOptions.put("timezone", "UTC+05:30");
        ltOptions.put("geoLocation", "IN");
        options.setCapability("LT:Options", ltOptions);

        driver = new RemoteWebDriver(new URL(gridUrl), options);
    }

    @BeforeMethod
    public void openPlayground() {
        driver.get("https://www.testmuai.com/selenium-playground/");
        driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(15));
        driver.manage().timeouts().pageLoadTimeout(Duration.ofSeconds(15));
    }

    @Test
    public void verifyPlaygroundLoaded() {
        WebElement heading = driver.findElement(By.tagName("h1"));
        assert heading.isDisplayed();
        status = true;
    }

    @AfterClass
    public void tearDown() {
        if (driver != null) {
            ((JavascriptExecutor) driver).executeScript("lambda-status=" + status);
            driver.quit();
        }
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd">
<suite thread-count="3" name="CapabilitiesDemoSuite" parallel="tests">
  <test name="ChromeLatestWin11">
    <parameter name="browser" value="chrome"/>
    <parameter name="version" value="latest"/>
    <classes>
      <class name="com.testmuai.CapabilitiesDemoTest"/>
    </classes>
  </test>
</suite>

Output on the TestMu AI Automation Dashboard

After execution, the TestMu AI dashboard surfaces network logs, command logs, metadata, video recording, and screenshots for the build. The capability values you set (build, name, browserVersion, platformName, LT:Options keys) are echoed back in the build metadata so you can correlate failed runs with the exact capabilities that produced them. For dashboard setup and walkthroughs, see the TestMu AI Selenium capabilities documentation.

Example for Desired Capabilities in Appium Testing

When a new automation session is requested, the Appium client sends a JSON object to the Appium server containing the desired capabilities as key-value pairs. Those values tell the Appium driver how to start the session and which device, OS, app, and automation engine to use.

Capabilities can be defined inside a desired capabilities file on the Appium server or passed at session creation from the WebDriver client. The example below uses the Appium 2.x JSON shape with the appium: prefix on non-W3C keys.

{
  "platformName": "Android",
  "appium:platformVersion": "14.0",
  "appium:deviceName": "Samsung Galaxy S24",
  "appium:automationName": "UiAutomator2",
  "appium:app": "/absolute/path/to/app-under-test.apk"
}

This block instructs the Appium driver to start a session on a Samsung Galaxy S24 running Android 14, use the UiAutomator2 automation engine, and install the APK at the given path.

General or Standard Desired Capabilities in Appium

• appium:automationName: Selects the automation engine. Common values: UiAutomator2 or Espresso for Android, XCUITest for iOS.
• platformName: Mobile OS, iOS or Android. W3C standard, no prefix.
• appium:platformVersion: Mobile OS version on which the test should run.
• appium:deviceName: Target mobile device name, for example Samsung Galaxy S24.
• appium:app: Absolute local path or HTTP URL to the application under test.
• browserName: Use this for mobile web tests, for example Safari on iOS or Chrome on Android. W3C standard, no prefix. Leave empty for native app tests.
• appium:language: Sets the device language for Android or iOS.
• appium:newCommandTimeout: Seconds Appium waits for a new command before ending an idle session.

Other general capabilities include appium:noReset, appium:fullReset, and appium:eventTimings. Refer to the official Appium docs for the complete list of vendor-prefixed keys.

Desired Capabilities in Appium for Android

• appium:appActivity: Android activity to launch from the package, for example .MainActivity or .Settings.
• appium:appPackage: Java package of the Android app to launch, for example com.example.android.testApp. Defaults to the value in the package manifest.
• appium:appWaitActivity: Activity to wait for after launch.
• appium:appWaitPackage: Java package to wait for after launch.
• appium:appWaitDuration: Milliseconds to wait for the appWaitActivity to launch.
• appium:deviceReadyTimeout: Seconds the driver waits for the device under test to become ready. Other Android-only keys include appium:adbPort, appium:systemPort, appium:remoteAdbHost, and appium:androidInstallPath.

Desired Capabilities in Appium for iOS

• appium:calendarFormat: Calendar format for the iOS simulator, for example Gregorian.
• appium:launchTimeout: Milliseconds the driver waits before treating an iOS session as failed.
• appium:autoAcceptAlerts: Auto-accepts iOS system alerts (location, contacts, notifications).
• appium:autoDismissAlerts: Auto-dismisses iOS system alerts when they appear.
• appium:safariInitialUrl: Initial URL Safari opens to when launched.
• appium:appName: Display name of the application under test.

Other iOS-only keys include appium:safariAllowPopups and appium:customSSLCert. The pattern is consistent: any key not in the W3C standard set takes the appium: prefix in Appium 2.x.

TestMu AI Capabilities Generator for Appium

The TestMu AI Capabilities Generator also covers Appium under its Appium tab. You can pick the OS (Android or iOS), OS version, device model, automation engine, and app source, and the generator returns the corresponding capability block in your chosen language with the correct appium: prefixes already applied.

Configure your mobile automation tests on the TestMu AI cloud grid using the real device capabilities generator.