Free tools Windows power users keep installed
One-click scans. No signup required.
Some links on this page are affiliate links: if you buy through them we may earn a commission, at no extra cost to you.
The fastest reliable fix is to identify the Chrome binary and switches Selenium actually uses, launch that exact command outside WebDriver, and then check browser/driver major versions. A DevToolsActivePort file doesn't exist message only means Chrome exited before ChromeDriver connected; it does not identify the cause. The failure is usually a version mismatch, wrong executable, unsupported headless syntax, a broken installation, or a user/container environment problem.
Use this decision path first
- Record versions and paths. Capture Selenium, Chrome, and ChromeDriver versions, plus the executable selected by Selenium. Confirm Chrome and ChromeDriver have the same major version.
- Reproduce the exact launch. Turn on ChromeDriver logging, copy the Chrome binary path and every argument from the log, and run that command directly as the same user in the same CI, service, or container environment.
- Branch on the result. If direct Chrome launch fails, repair the browser, operating-system dependencies, permissions, or runtime. If it succeeds, reduce the WebDriver script to a minimal session and compare its user, environment, profile, and service settings.
- Validate headless syntax. Use a flag supported by the installed Chrome version; do not paste a flag collection from an unrelated version.
Why Chrome exits before Selenium connects
ChromeDriver starts Chrome with a temporary profile and a DevTools connection. If Chrome terminates before that endpoint is ready, Selenium reports a startup error. The visible message can mention DevToolsActivePort, “Chrome failed to start: exited abnormally,” or a session-not-created exception. Those are symptoms of an unsuccessful launch, not proof that one missing flag is the cause.
The same symptom can result from a driver built for another Chrome major version, a stale executable found on PATH, a damaged installation, an unsupported option, insufficient permissions, a service running as root, or a container without the expected libraries and display-related configuration.
Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Fix the driver behind crashes, sound loss and screen glitches3Repair Windows errors before they cause bigger problemsCheck versions, binaries, and driver resolution
Verify the installed versions
On the machine that actually runs the test, print the browser and driver versions (not the versions on your development laptop):
#1 Best Overall
google-chrome --version
chromium --version
chromedriver --version
python -c "import selenium; print(selenium.__version__)"Use whichever browser command exists. The Chrome and ChromeDriver major numbers should match (for example, 128.x with 128.x). A minor or patch difference can be normal, but a major mismatch commonly prevents session creation. Also check for multiple installations; an explicitly configured binary may differ from the one you tested in a terminal.
Know what Selenium Manager did
In supported Selenium 4 setups, Selenium Manager can resolve a missing driver and manage Chrome for Testing. Its Chrome management is documented from Selenium 4.11.0 onward. It cannot repair a broken browser installation, fix missing operating-system libraries, or make an unsuitable container environment safe. If you do not pass a driver path, inspect Selenium/ChromeDriver logs and enable verbose output so you know which executable was selected instead of assuming PATH or a cache is correct.
Run the exact Chrome command outside WebDriver
Enable ChromeDriver logging
Python example:
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
options = Options()
options.add_argument("--headless")
options.add_argument("--remote-debugging-port=0")
service = Service(log_output="chromedriver.log")
driver = webdriver.Chrome(service=service, options=options)
try:
driver.get("https://example.com")
print(driver.title)
finally:
driver.quit()For a driver installed on a known path, set Service(executable_path="/absolute/path/chromedriver", log_output="chromedriver.log"). Read the log for the Chrome binary and the complete argument list. ChromeDriver’s own diagnostics are more useful than adding random switches.
Quick wins for a faster PC:
Repair Windows errors before they cause bigger problemsFix Now →Scan for outdated or missing drivers - takes under a minuteDriver Scan →Clear out junk files and repair common Windows errorsFree Scan →Replay the launch
Copy the logged executable and arguments into a shell command, preserving quoting. Run it under the same account and environment as the failing job. If it exits immediately, inspect the browser’s stderr, repair or reinstall Chrome, verify shared libraries and file permissions, and check that the binary is not being blocked by a security policy. If it stays running, stop it and make the WebDriver test minimal: one temporary profile, one URL, and no framework hooks. Then add your normal options one at a time.
Rank #2
Use headless syntax that matches your Chrome version
Current unified headless
Chrome’s current documentation describes unified headless with --headless. Since Chrome 112, headless uses the normal browser implementation and creates platform windows without displaying them. This is different from older, separate headless code.
Older syntax and the Chrome 132 change
Selenium examples have commonly shown --headless=new. That spelling can be appropriate for versions that introduced the new implementation, but no single spelling is correct for every historical release. Chrome 132.0.6793.0 removed the old headless implementation from the main Chrome binary; the old implementation is available only as the separate chrome-headless-shell binary. Therefore, first identify the installed version, then use the syntax supported by that browser. An unsupported flag can cause an early exit just like a bad binary.
Do not combine several historical headless flags “just in case.” Start with one supported headless option, confirm a session, and only then add viewport, download, proxy, or rendering options.
Check the account, sandbox, and execution environment
Linux root and sandbox failures
ChromeDriver’s official guidance identifies running Chrome as root on Linux as a common startup-crash cause. Configure the job to run as a regular user with a writable home and temporary directory. The documented --no-sandbox workaround is unsupported and highly discouraged; do not treat it as a routine fix or a security-neutral setting.
Services, CI, and containers
A command that works in your interactive shell may fail as a system service because it has a different user, HOME, TMPDIR, PATH, mounted filesystems, policies, or installed libraries. Test Chrome under the exact service account. In a container, verify the image contains the libraries required by that Chrome build, that the executable is permitted to run, and that the temporary profile directory is writable. An all-users browser installation can help when only a service account cannot see a per-user installation, but it does not replace version and permission checks.
Profile and cleanup issues
Let ChromeDriver create a temporary profile while diagnosing. A locked or corrupt profile, a profile owned by another user, or a read-only temporary directory can make Chrome exit before DevTools starts. Remove stale test processes and temporary profiles, then retry with a fresh directory. Avoid sharing one profile between parallel sessions.
Minimal known-good Selenium sessions
Python
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
options = Options()
options.add_argument("--headless")
options.add_argument("--window-size=1280,900")
# Set this only when you have verified the path:
# options.binary_location = "/usr/bin/google-chrome"
driver = webdriver.Chrome(options=options)
try:
driver.get("https://example.com")
print(driver.title)
finally:
driver.quit()Once this works, add your real arguments individually: proxy, custom user agent, extensions, profile, downloads, or automation framework hooks. The first added option that breaks startup is the strongest lead.
Windows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallOutdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchJava
ChromeOptions options = new ChromeOptions();
options.addArguments("--headless");
WebDriver driver = new ChromeDriver(options);
try {
driver.get("https://example.com");
System.out.println(driver.getTitle());
} finally {
driver.quit();
}Match the symptom to the likely cause
| What you observe | Most useful check | Correction |
|---|---|---|
| Session-not-created with a version message | Compare Chrome and ChromeDriver major versions | Install a matching driver or let a supported Selenium Manager setup resolve it; remove stale driver paths. |
DevToolsActivePort and Chrome exits instantly |
Replay the exact logged command directly | Fix the direct browser failure, unsupported flag, permissions, or environment before changing Selenium code. |
| Works locally, fails in CI | Compare account, image, PATH, HOME, temp directory, libraries, and policies |
Run under the same identity and install the required browser dependencies in the job image. |
| Fails only when launched by a Linux service | Check whether the service runs as root and whether its profile/temp paths are writable | Use a regular user, writable directories, and a browser installation visible to that account. |
| Fails after changing headless flags | Check the Chrome version against the flag’s history | Use the supported --headless or version-appropriate syntax; remove obsolete flags. |
| Fails only with a custom binary | Print options.binary_location and launch that path manually |
Point to a real executable of the expected version or remove the override. |
Troubleshooting checklist
- Log Selenium, Chrome, and ChromeDriver versions from the failing machine.
- Confirm the browser and driver major versions match.
- Identify the actual browser executable, driver executable, user, and working directories.
- Enable ChromeDriver logging and preserve the complete command line.
- Replay that command outside WebDriver with the same account and environment.
- Use a fresh temporary profile and writable temporary directory.
- Remove every nonessential option, then reintroduce options one by one.
- On Linux, avoid root; do not rely on
--no-sandboxas a fix. - For Chrome 132 and later, do not expect the old headless implementation in the main binary; use the supported unified mode or the separate shell binary when that legacy behavior is specifically required.
Performance, reliability, and cost considerations
Headless mode removes display overhead, but startup still depends on browser process creation, profile I/O, page load, and the machine’s CPU and memory. Reusing a driver for a sequence of pages is usually cheaper than creating a new Chrome process for every URL, while isolated temporary profiles reduce cross-test contamination. In parallel runs, give each session its own profile and enough memory; resource exhaustion can look like an ordinary startup crash.
For repeatable diagnosis, pin the browser/driver major version in your CI image, log the selected paths, and retain ChromeDriver logs as build artifacts. Selenium Manager reduces manual driver distribution in supported configurations, but a pinned, known-good browser image remains useful when reproducibility matters.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Or skip the browser setup
If your goal is simply a clean website image or PDF rather than browser automation, ScreenshotNeo provides a single HTTP call and an MCP server for AI clients. It accepts cookie/consent banners before capture and removes more than 60 known consent platforms, newsletter popups, and chat widgets; each cleanup step can be disabled. Bot checks, CAPTCHAs, blank pages, timeouts, failed loads, and cache hits are not billed, and the response identifies the page verdict and billing status in headers.
cURL:
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpPython:
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)Node.js:
const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);See the ScreenshotNeo documentation for options such as full-page and element captures, device presets, custom CSS/JavaScript, waits, request blocking, cookies and headers, PDFs, signed links, asynchronous jobs, bulk capture, caching, and the usage API. Its MCP tools—take_screenshot, get_page_info, and capture_pdf—let Claude, Cursor, or another MCP client perform captures. The Free plan includes 1,000 screenshots per month with no card; paid plans start at $5 for 3,000. Create a free ScreenshotNeo account.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
When a managed grid is appropriate
If you need concurrent coverage across real devices and browsers, BrowserStack documents a Selenium grid, while Sauce Labs provides Selenium quickstarts and cloud continuous testing. These services can provide a controlled remote environment, but they do not repair a broken local Chrome installation; first establish whether your failure is local, then decide whether remote execution fits your coverage and operational needs.
FAQ
Does DevToolsActivePort prove that --no-sandbox is missing?
No. It only indicates that Chrome did not stay alive long enough for ChromeDriver to connect. Logs and direct replay distinguish root execution from version, binary, flag, permission, and environment failures.
Should I always use --headless=new?
No. Headless flag behavior changed across Chrome releases. Select syntax supported by the installed browser; current unified headless documentation uses --headless.
Can Selenium Manager fix a crashing Chrome?
No. It can help resolve a missing driver in supported setups, but it does not repair an invalid browser installation or unsuitable runtime environment.
Recommended Free Tools
Frequently Asked Questions
How do I prove whether Selenium or Chrome is at fault?
Replay the exact Chrome executable and arguments from ChromeDriver’s verbose log under the same user and environment. A direct failure is a browser or runtime problem; a direct success points to the WebDriver harness or its environment.
What major versions must match?
Chrome and ChromeDriver should share the same major version. Check the versions on the machine running the failing test, including any explicitly configured binary.
Is running Chrome as root supported?
ChromeDriver identifies root execution on Linux as a common startup-crash cause. Use a regular user; its documented –no-sandbox workaround is unsupported and highly discouraged.
The Bottom Line
Diagnose the launch you actually have: match Chrome and ChromeDriver majors, replay the logged command directly, use version-appropriate headless syntax, and run Chrome as a regular user in the same environment as the test.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
