Selenium Manager Status and Browser Driver Setup

Selenium Manager is Selenium’s built-in local tool for finding and managing browser drivers. With a current Selenium binding and the browser you want to automate installed, the normal setup is to create a WebDriver instance; Selenium Manager resolves a compatible driver, downloads it when needed, and caches it. Newer Selenium Manager behavior can also provision a browser when needed. There is no hosted Selenium Manager service whose uptime determines whether your local session starts: “status” means inspecting the Manager process, its detected browser and driver, cache, and network activity.

Start with the binding’s normal WebDriver constructor. If setup fails, enable logs or run Selenium Manager with --debug and inspect the browser discovery, version resolution, cache, and download messages. Use a manually downloaded driver on PATH or a binding-specific Service path only when you need pinned or offline setup.

1. What Selenium Manager does and what “status” means

WebDriver sends commands to a browser through a browser-specific driver. Selenium Manager automates discovery and acquisition of that driver. Selenium describes it as a command-line tool implemented in Rust for automated driver and browser management. Bindings invoke it by default in current Selenium versions.

Selenium’s project guide describes driver discovery, matching, download, and caching from Selenium 4.6, and browser download when needed from Selenium 4.11. Exact behavior and supported configuration depend on the Selenium release and language binding. Check the documentation for the version installed in your project.

There is no remote Manager dashboard to query for a service status. Useful local “status” details are:

Which browser and version Manager detected.
Whether it found a driver on PATH or resolved one to download.
Which cache it checked or used.
Whether it made a metadata or download request, and whether that request succeeded.
Which configuration source supplied a setting.

2. Standard setup by language

Install a current Selenium binding and the browser you intend to use. Then use that binding’s ordinary WebDriver constructor or builder. On the first run, Manager may need network access to resolve and download a compatible driver; later runs can use the cache.

Python

from selenium import webdriver

# Requires a current Selenium Python package and Chrome installed.
driver = webdriver.Chrome()
try:
    driver.get("https://example.com")
    print(driver.title)
finally:
    driver.quit()

For Firefox, use webdriver.Firefox() with Firefox installed. Do not pass an old executable_path argument as the default setup pattern; use the current binding API and Selenium Manager unless your environment requires a manually managed driver.

Java

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

public class Main {
    public static void main(String[] args) {
        WebDriver driver = new ChromeDriver();
        try {
            driver.get("https://example.com");
            System.out.println(driver.getTitle());
        } finally {
            driver.quit();
        }
    }
}

Use the current Selenium Java dependency for your build tool. With the standard constructor, current Selenium can invoke Manager to locate a compatible Chrome driver.

JavaScript (Node.js)

const { Builder } = require('selenium-webdriver');

(async () => {
  const driver = await new Builder().forBrowser('chrome').build();
  try {
    await driver.get('https://example.com');
    console.log(await driver.getTitle());
  } finally {
    await driver.quit();
  }
})();

Install the current selenium-webdriver package and Chrome. Use the builder API documented for the package version in your project.

C#

using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;

using IWebDriver driver = new ChromeDriver();
driver.Navigate().GoToUrl("https://example.com");
Console.WriteLine(driver.Title);

Current Selenium bindings handle driver management through the normal service and driver APIs. Consult the versioned .NET API reference if you need a custom service or explicit executable path.

3. Inspect Selenium Manager locally

When a session fails to start, inspect Manager’s own output before changing driver paths. Locate the Selenium Manager binary shipped with the installed binding; its location varies by package and operating system. Run the binary with a browser selection and --debug. For example, from a shell where the binary is available:

selenium-manager --browser chrome --debug

The command is illustrative: if the binary is not on PATH, run the copy associated with your installed Selenium package. Use --help on that exact binary to confirm accepted arguments. Debug output can show PATH checks, browser discovery, version resolution, cache use, and network download attempts. Trace controls and other options vary by Manager release.

Confirm the Selenium binding version in the project.
Run the application with its normal WebDriver constructor and capture the complete exception and log output.
Run Manager’s debug command for the browser in question, using the binary shipped with that installation.
Compare the detected browser version, resolved driver, cache path, and any network or proxy error with the target environment.
Check configuration precedence before changing settings: command-line arguments override se-config.toml, which overrides corresponding SE_ environment variables.

Configuration documentation describes the default cache as ~/.cache/selenium, as well as configurable offline behavior, proxy, and debug or trace controls. Check the Manager documentation matching your installed version for exact option names and support.

4. Choose automatic or manual driver setup

Method	Good fit	Trade-off
Selenium Manager	Ordinary local development and environments where automatic resolution is allowed.	First resolution may need network access; behavior depends on Selenium/Manager version and configuration.
Driver on PATH	Controlled machines where an administrator provisions a compatible driver for multiple projects.	You maintain version compatibility and machine PATH configuration.
Explicit Service path	Pinned or isolated environments that need a known driver executable.	The path is often machine-specific and must be maintained alongside browser updates.

For a manual fallback, download the browser vendor’s driver version compatible with the installed browser, then either put the executable on PATH or provide its location through the binding’s local Service object. The exact Service API differs by language and release; use the official binding example for your version. Avoid copying legacy constructor arguments from older tutorials without checking whether they remain supported.

For CI, decide explicitly whether the job is allowed to access Selenium metadata and driver download endpoints. If not, provision the browser and matching driver in the image or workspace and use PATH or a configured Service path. Keep the browser and driver versions together in the CI image or setup so that a browser update does not silently leave an incompatible pinned driver behind.

5. Network, cache, and configuration

Automatic management can require outbound network access to retrieve metadata and driver or browser downloads. In a corporate network, configure the documented proxy setting for your installed Manager version and verify that policy permits the required requests. A cached compatible asset may allow startup without a new download, but do not assume the cache contains the version needed by a changed browser.

Check configuration in this order:

Explicit command-line options passed to Manager.
se-config.toml in the Selenium cache.
Corresponding SE_ environment variables.

If an environment variable seems ignored, a CLI option or TOML setting may override it. Review the effective debug output and exact version’s configuration guide. Offline mode is useful when the needed assets are already provisioned or cached; it cannot obtain a missing driver or browser while network access is disabled.

6. Common errors and fixes

Symptom	Likely cause	What to do
“Unable to locate driver” or executable not found	Old Selenium, Manager not invoked as expected, browser not detected, or manual path/PATH is wrong.	Update the binding, inspect full logs and Manager debug output, confirm the browser is installed, and check PATH/cache. If automatic resolution is unavailable, use the documented PATH or Service fallback.
Metadata or download request fails	Network policy, proxy configuration, DNS, or unavailable outbound access.	Check proxy and network policy, read the Manager error, and confirm whether a usable compatible cache entry exists. Provision assets manually if the environment must remain offline.
Environment setting has no effect	A higher-precedence CLI argument or `se-config.toml` value overrides the `SE_` variable.	Inspect all three configuration sources in precedence order and remove or update the overriding value.
Browser starts, then commands fail or tests flake	Synchronization problems or browser/driver faults rather than driver discovery.	Use the actual exception and browser logs; check waits and timing. Run the same command in another browser to help distinguish a browser-specific driver issue from test logic.
A tutorial asks for a driver-manager dependency or hardcoded legacy path	The guide may describe an older Selenium API or setup flow.	Check current binding docs first. Manager is the default management mechanism in current bindings; add manual configuration only for a concrete constraint.

7. Reliability, performance, and cost considerations

Manager reduces routine setup work by resolving and caching assets locally. Initial startup can take longer when metadata lookup or downloads are needed; cache hits avoid repeating that acquisition. Network restrictions, a cold cache, or a browser version change can make setup fail or take longer. For repeatable CI, choose between allowing Manager’s network resolution and provisioning a known browser/driver pair in the environment.

Selenium Manager is local software invoked by the binding, not a hosted service with a live uptime status. Diagnose the local process, browser, driver, cache, and network instead of looking for a remote Manager status page. Selenium itself is software; the setup guidance here does not prescribe a paid driver service. Browser automation can still consume machine resources, so close sessions with quit() even when a test throws.

8. Or skip the browser setup

If the task is to produce a website screenshot rather than interact with a browser, ScreenshotNeo provides a screenshot API and MCP server. Its one-call capture does not require you to install or manage Selenium and a browser driver. See the ScreenshotNeo API documentation.

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webp

import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"}, timeout=90)
open("shot.webp", "wb").write(r.content)

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);

ScreenshotNeo removes cookie and consent banners, newsletter popups, and chat widgets before capture. Bot checks, blank pages, failed loads, timeouts, and cache hits are not billed, and responses identify the page verdict and billing status in headers. Its MCP server includes screenshot, page-info, and PDF tools for AI agents. The free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000 screenshots. Sign up for 1,000 free screenshots a month, with no card.

9. FAQ

Do I still need to download ChromeDriver?

Usually not for a standard setup with a current Selenium binding and Chrome installed. Selenium Manager handles discovery and acquisition by default. Download and manage it yourself when your environment requires a pinned or offline driver.

Is Selenium Manager an online service?

No. It is a local command-line utility invoked by Selenium bindings. Network access may be needed for metadata and downloads, but session startup does not depend on a hosted Manager service status.

Where does Selenium Manager keep its cache?

The documented default is ~/.cache/selenium. The cache location and exact configuration options can vary by release or configuration, so inspect the installed Manager’s documentation and debug output.

Can I use Selenium without network access?

Yes, if the required browser and compatible driver are already available locally or cached and Manager is configured appropriately, or if you provision the driver and use a manual path. Offline mode cannot download a missing asset.

Should I add a third-party driver manager package?

Not as the routine first step for current Selenium. Check the binding’s current documentation; its built-in Manager is the default path.