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 Selenium message “failed to create a Chrome process” means ChromeDriver started, but Chrome exited before a WebDriver session could be established. Fix it by reproducing the same Chrome launch outside Selenium, then verify browser/driver compatibility, the executable path, a writable profile, headless or service settings, Linux dependencies, and Selenium Manager’s network access. The exact failing layer matters: changing Selenium selectors or retrying the session cannot repair a Chrome process that never stayed alive.
What the error actually means
ChromeDriver is a small server that launches Chrome and negotiates a WebDriver session. This error occurs during that startup handshake. Chrome may be missing, incompatible with the selected driver, unable to write its profile, missing a shared library, unable to access a display, or terminated by a service/container policy. ChromeDriver can therefore appear to “start successfully” while the browser process immediately exits.
Save the complete first exception, ChromeDriver service log, Chrome executable path, Chrome version, driver version, operating system and architecture, account name, working directory, environment variables, and every launch argument. Do not replace the original stderr output with a generic retry: the first failure usually identifies the layer that needs repair.
Use this diagnostic order
- Launch Chrome directly as the test account. Use the exact executable and the same machine context as Selenium. If Chrome exits directly, repair Chrome, the profile, permissions, display, or dependencies before changing WebDriver code.
- Check versions and driver selection. Chrome and ChromeDriver should match. Selenium 4.6 and newer can normally use Selenium Manager when you do not supply a driver location.
- Confirm the browser binary. A nonstandard installation requires an absolute executable path that the test account can read and execute.
- Use a fresh writable profile. Never share an open desktop profile between Chrome processes. Give every concurrent run its own temporary
--user-data-dir. - Match the runtime context. Headless CI, Docker, Jenkins, a scheduled task, and a Windows service can have different permissions, home directories, temporary directories, display variables, sandbox policy, and network access than an interactive shell.
- Check dependencies and network restrictions. A missing Linux library can kill Chrome before a session exists. Selenium Manager may also need DNS, proxy, firewall, and internet access to discover or download a driver.
1. Reproduce Chrome outside Selenium
Chrome’s troubleshooting guidance recommends running the browser from a normal user command prompt, particularly when the test is launched by an IDE, special harness, or continuous-build system. This separates a browser/environment failure from a WebDriver API failure.
#1 Best Overall
Interactive check
Find the executable Selenium is supposed to use, then run it as the same account. On Windows, launch the installed chrome.exe from PowerShell or Command Prompt; on macOS use the executable inside the Chrome application bundle; on Linux use the distribution’s google-chrome or chromium path. Add a temporary, unique profile directory so an already-open desktop Chrome cannot lock the profile.
chrome --user-data-dir=/tmp/chrome-direct-test --headless=new about:blankReplace chrome with the absolute executable path on your system. If this command fails, inspect its stderr and fix that problem first. Typical causes are a locked profile, an unwritable temporary directory, no display in a non-headless run, a blocked sandbox, or a missing shared library.
Why this test is decisive
If direct Chrome launch works but Selenium fails, concentrate on driver selection, Selenium Manager, ChromeOptions, and the service account’s environment. If direct launch fails under the same account, changing locators, waits, or retry counts will not help because no WebDriver session can exist yet.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
2. Make Chrome and ChromeDriver compatible
ChromeDriver and Chrome should match. A manually pinned driver can become incompatible after Chrome updates, while an old Selenium package may not manage drivers correctly. With Selenium 4.6 or later, the normal path is to omit a hard-coded driver path and let Selenium Manager discover a suitable driver.
Preferred Selenium 4 approach
Upgrade Selenium in the environment that actually runs the test, then create the driver without passing a driver executable:
python -m pip install --upgrade seleniumSelenium Manager may discover the installed browser and obtain the corresponding driver. In a locked-down environment, it can fail when DNS, proxy, firewall, or offline policies block Chrome for Testing endpoints. In that case, provide a known-good local driver and browser path instead of repeatedly retrying automatic discovery.
Rank #2
When you must pin a driver
Use Selenium’s Service API with an explicitly supported driver path. Record the Chrome and ChromeDriver versions in your build output, and update them together. Avoid silently mixing a system Chrome with a driver copied from another machine or architecture.
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Scan for outdated or missing drivers - takes under a minuteDriver Scan →from selenium import webdriver
from selenium.webdriver.chrome.service import Service
service = Service("/absolute/path/to/chromedriver")
driver = webdriver.Chrome(service=service)
driver.quit()On Windows, use a path such as C:\tools\chromedriver.exe; on Unix-like systems, ensure the file is executable and readable by the service account.
3. Set the correct Chrome executable
ChromeOptions must point to the real executable when Chrome is installed in a nonstandard location, when a portable build is used, or when several browser channels are present. The path must be absolute and runnable by the account that owns the test process.
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
options = Options()
options.binary_location = "/absolute/path/to/chrome"
driver = webdriver.Chrome(options=options)
driver.quit()Verify the path independently with the direct-launch test. A path that works in your desktop shell may not exist for a Windows service, container, or CI user. Also check architecture: a 32-bit or ARM environment needs a compatible browser and driver build.
4. Isolate every run with a writable profile
Chrome refuses or exits when two processes try to use the same profile, when stale lock files remain, or when the account cannot write the profile and cache directories. Never point automation at your normal signed-in desktop profile. Create a unique temporary directory for each run and delete it after the browser exits.
Recommended Free Tools
import tempfile
from pathlib import Path
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
profile = tempfile.mkdtemp(prefix="selenium-chrome-")
options = Options()
options.add_argument("--headless=new")
options.add_argument(f"--user-data-dir={profile}")
driver = webdriver.Chrome(options=options)
try:
driver.get("https://example.com")
print(driver.title)
finally:
driver.quit()
The illustrative directory is unique because Python creates it. In parallel jobs, do not reuse a fixed path such as /tmp/selenium-profile. Remove stale locks only after confirming that no Chrome process still owns the profile. Ensure the parent temporary directory has free space and appropriate permissions.
5. Handle headless, display, and service environments
Headless Linux and CI
Use Selenium’s current --headless=new argument where headless execution is required. Run one diagnostic job without headless when possible; a visible run can reveal display or GPU errors that headless output hides. If the machine has no display, a non-headless launch needs a correctly configured display server or virtual display.
options.add_argument("--headless=new")Do not add random flags copied from unrelated Docker examples. Flags such as disabling the sandbox change security behavior and should only be used when your container policy requires them and you understand the risk. First compare the failing environment with a working interactive one.
Scheduled tasks, Windows services, and CI agents
Run the direct Chrome command under the same account and service definition used by the test. Compare:
- the executable and working-directory paths;
- home, temporary, PATH, proxy, and display environment variables;
- read/write permissions for the browser, profile, cache, and log directories;
- desktop-session availability and whether the account is allowed to launch GUI processes;
- container sandbox, shared-memory, and process limits; and
- architecture and installed system packages.
ChromeDriver documentation specifically identifies IDEs, special harnesses, and continuous-build systems as contexts where immediate startup failures commonly appear. A test that succeeds in an interactive terminal is not proof that the service account can launch Chrome.
6. Repair missing Linux libraries and runtime dependencies
Chrome can terminate before ChromeDriver receives a session when a shared library is absent. Selenium Manager documentation gives a missing libatk-1.0.so.0 example where installing the distribution package that provides libatk-bridge2.0-0 resolves the dependency. Package names differ by distribution, so use your operating system’s package manager and dependency tools rather than copying a package name blindly.
Run the browser directly and read the loader error. On Linux, inspect the executable’s shared libraries with the platform’s normal tooling, install the package that supplies the missing soname, and rerun the direct launch. Also check available shared memory, disk space, font packages, and container restrictions if Chrome starts and then disappears.
7. Check Selenium Manager’s network path
Selenium Manager may contact Chrome for Testing endpoints to discover and download drivers or browsers. Proxy authentication, firewall rules, DNS failures, TLS interception, and offline build agents can therefore look like a Chrome startup failure.
The Tool Desk
Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →- Confirm the test account can resolve and reach the required endpoints.
- Configure the documented proxy support for Selenium Manager when a proxy is mandatory.
- In offline environments, cache or install a compatible driver and browser, then pass their local paths through the Service API and ChromeOptions.
- Log the selected browser and driver paths so a future update cannot silently change them.
If the driver is already present and Chrome launches directly, disabling automatic discovery in favor of known local paths can make builds deterministic.
A minimal, safer Python baseline
This complete smoke test combines a current headless mode, a unique writable profile, and Selenium Manager. Replace the URL with your test target and use an absolute binary_location only when detection fails.
import tempfile
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
profile = tempfile.mkdtemp(prefix="selenium-profile-")
options = Options()
options.add_argument("--headless=new")
options.add_argument(f"--user-data-dir={profile}")
# options.binary_location = "/absolute/path/to/chrome" # nonstandard install only
driver = webdriver.Chrome(options=options)
try:
driver.get("https://example.com")
print(driver.title)
finally:
driver.quit()
For repeated or parallel runs, retain the unique-directory behavior shown here. If this smoke test fails, preserve its complete exception and driver log before adding application code.
Troubleshooting by symptom
| Symptom | Likely layer | Action |
|---|---|---|
| Chrome exits in the direct command | Browser, profile, permissions, display, or dependencies | Fix the direct-launch error under the test account; Selenium changes cannot repair it. |
| “Only works on my laptop” | Service/CI environment | Compare account, paths, environment variables, display, permissions, architecture, and packages. |
| Failure began after Chrome updated | Driver mismatch | Use Selenium Manager or update the pinned ChromeDriver with Chrome. |
| Works serially but not in parallel | Profile collision or resource limits | Create a unique profile per process and check disk, shared memory, and process limits. |
| Driver download or discovery times out | Proxy, DNS, firewall, or offline policy | Configure the documented proxy or provide local browser and driver paths. |
Linux reports a missing .so file |
Runtime dependency | Install the distribution package that provides that library, then retest Chrome directly. |
| Headless fails but visible mode works | Headless/display-specific setup | Use --headless=new, inspect headless logs, and verify the service has required runtime resources. |
Performance, reliability, and maintenance choices
- Automatic Selenium Manager: less manual maintenance and usually the simplest Selenium 4.6+ setup, but it depends on supported discovery and network access.
- Pinned browser and driver: reproducible offline builds, but you must update and test both together after browser releases.
- Fresh profiles: avoid locks and state leakage, at the cost of profile creation and repeated login/setup work.
- Headless mode: suitable for servers without a desktop session, but it still needs a complete browser runtime and compatible flags.
Keep a small startup smoke test in CI. Log versions, paths, account, launch arguments, and the driver service output. This catches a broken browser image or driver update before a large test suite produces hundreds of misleading failures.
Or skip the browser setup
If your goal is a clean website image rather than interactive Selenium automation, ScreenshotNeo provides a single screenshot API request. It accepts cookie and consent banners like a visitor, then removes more than 60 known consent platforms, newsletter popups, and chat widgets before capture; each step can be disabled. Only clean shots are billed: bot checks or CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing, and the response identifies the result with X-Page-Verdict and X-Billed headers. It also has an MCP server for Claude, Cursor, and other MCP clients, with take_screenshot, get_page_info, and capture_pdf tools.
Use the API documentation at https://screenshotneo.com/docs/ for all options, including full-page lazy-image loading, CSS-selector element capture, dark mode, device presets, retina scale, PDF paper and page ranges, custom CSS or JavaScript, clicks, waits, blocked resources, headers, cookies, user agents, authorization, timezone, geolocation, transparent backgrounds, resizing, TTL caching, signed image links, asynchronous webhooks, bulk capture of up to 100 URLs per call, usage reporting, and OpenAPI compatibility.
Best Value
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpimport 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}`);There is a free allowance of 1,000 screenshots per month with no card. Paid plans start at $5 for 3,000 shots; every feature is on every plan. Create a free ScreenshotNeo account to try it.
FAQ
Does reinstalling Selenium fix this error?
Only when the installed package is genuinely too old or broken. First establish whether Chrome launches directly and whether the browser and driver match; reinstalling cannot fix a missing library, locked profile, or blocked network.
Should I always add --no-sandbox?
No. It weakens Chrome’s sandbox. Diagnose the container or account policy first and add security-affecting flags only when your deployment requires them.
Can I reuse a logged-in Chrome profile?
It is unsafe for concurrent automation and commonly causes profile-lock failures. Use a separate profile and automate required authentication in a controlled test setup.
Frequently Asked Questions
Does reinstalling Selenium fix this error?
Only when the package itself is outdated or damaged; verify direct Chrome launch, versions, profile permissions, and dependencies first.
Should I always add –no-sandbox?
No. It reduces isolation and should be considered only after diagnosing a container policy that genuinely requires it.
Free tools Windows power users keep installed
One-click scans. No signup required.
Can I reuse my logged-in Chrome profile?
Avoid it for automation, especially in parallel. A dedicated profile prevents locks and state leakage.
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.
