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.
Run one independent Selenium WebDriver session per concurrent worker. Let Selenium Manager select a compatible ChromeDriver when your setup permits it, avoid sharing custom Chrome profiles or fixed ports, and inspect browser and driver logs when startup fails. For workloads that outgrow one machine, use Selenium Grid.
What “concurrent” means in Selenium
A WebDriver object represents a browser session. To run tests at the same time, each worker should create and own its own WebDriver session, then close it when its work finishes. Do not share one driver object between workers: they would issue commands to the same browser and interfere with each other’s navigation, cookies, and page state. Selenium documents both local driver-service startup and remote WebDriver sessions (Selenium WebDriver drivers).
ChromeDriver is a separate executable that Selenium uses to control Chrome. Chrome-specific startup settings belong in ChromeOptions. In a local run, Selenium starts a ChromeDriver service for the session; in a remote run, the driver connects to a remote WebDriver endpoint.
Start with independent local sessions
This Python example uses a thread pool for independent URL checks. It relies on Selenium Manager’s default driver resolution, creates one driver inside each task, and always calls quit() to close the browser and service.
#1 Best Overall
from concurrent.futures import ThreadPoolExecutor
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
def run_case(url, profile_dir=None):
options = Options()
if profile_dir:
# Must be different for every simultaneously running session.
options.add_argument(f"--user-data-dir={profile_dir}")
# Leave the driver executable unset so Selenium Manager can resolve it.
driver = webdriver.Chrome(options=options)
try:
driver.get(url)
return driver.title
finally:
driver.quit()
urls = ["https://example.com", "https://www.selenium.dev"]
with ThreadPoolExecutor(max_workers=2) as pool:
titles = list(pool.map(lambda url: run_case(url), urls))
print(titles)Install a current Selenium Python package in the environment where the script runs. Selenium Manager has shipped with Selenium releases since version 4.6; it can discover the installed browser, resolve a matching driver, download it, and cache it. It is the simplest starting point when the machine can reach the relevant browser-driver metadata services (Selenium Manager documentation).
When custom profiles are necessary
ChromeDriver normally creates a temporary profile for a session. If you pass --user-data-dir because a test needs a persistent profile, make the path unique per concurrently running worker. Two Chrome processes cannot safely use the same active profile; a collision can cause startup failure or corrupt test isolation. Prefer ChromeDriver’s temporary profile unless persistence is a real requirement (ChromeDriver capabilities).
Choose worker count for the machine
max_workers controls how many sessions your program attempts to start together; it does not guarantee that the host can sustain that many full Chrome processes. Start conservatively and increase concurrency only while CPU, memory, process limits, and test stability remain acceptable. If sessions slow down, crash, or time out under load, lower the worker count before treating each failure as a Selenium defect.
Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minutePC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Use a deliberate driver version strategy
For most developer machines and network-connected CI workers, leave the ChromeDriver executable unspecified and let Selenium Manager resolve it. This avoids accidentally selecting a stale driver found earlier on PATH. Selenium Manager is the official driver manager shipped with Selenium since 4.6 and can cache downloaded drivers after resolution (Selenium Manager documentation).
For reproducible or air-gapped builds, pin a controlled Chrome and ChromeDriver pair instead. Check compatibility deliberately, including the Chrome major version and ChromeDriver major version, and update them together. The Python API’s Service object starts and stops ChromeDriver; create a separate Service/driver instance per worker rather than trying to reuse a single service process across workers (Selenium Service documentation).
Python with an explicitly managed driver
Use this pattern only when your build deliberately provisions the driver binary. Set the executable path to the installed binary in your environment and ensure its version matches the browser.
from concurrent.futures import ThreadPoolExecutor
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.chrome.service import Service
CHROMEDRIVER = "/opt/webdrivers/chromedriver"
def run_case(url):
options = Options()
service = Service(executable_path=CHROMEDRIVER)
driver = webdriver.Chrome(service=service, options=options)
try:
driver.get(url)
return driver.title
finally:
driver.quit()
urls = ["https://example.com", "https://www.selenium.dev"]
with ThreadPoolExecutor(max_workers=2) as pool:
print(list(pool.map(run_case, urls)))Each call constructs its own Service object. Avoid supplying the same custom remote-debugging port to multiple Chrome processes. Likewise, do not hard-code one shared ChromeDriver service port for all workers; for ordinary local sessions, let Selenium’s Service start each driver without a manually shared port.
When local sessions are no longer enough
Local sessions are a good fit for small-to-medium suites on one host. Selenium Grid is the next step when you need remote nodes, distributed execution, or more simultaneous sessions than one machine can support. Grid lets an administrator configure node session capacity with --max-sessions. Its documentation shows an eight-CPU node configured for eight sessions as an example, not a universal capacity rule (Grid CLI options).
Rank #2
| Approach | Best fit | Main trade-off |
|---|---|---|
| Selenium Manager with local WebDriver | Small or medium parallel suites on one machine | Uses local CPU and RAM; first-time driver resolution needs access to driver metadata and downloads. |
| Pinned ChromeDriver with local WebDriver | Reproducible or air-gapped builds | Your team must update and validate the browser-driver pair deliberately. |
| Selenium Grid | Distributed runs or higher concurrency | Requires remote endpoint and node-capacity planning. |
For Grid, each worker should connect its own remote WebDriver session to the Grid endpoint rather than starting a local ChromeDriver. Grid can queue or reject work when configured capacity is exhausted, so align test parallelism with the available node slots.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Diagnose startup errors in a useful order
- Check browser and driver compatibility. For
session not createderrors mentioning versions, remove stale manually downloaded drivers from the environment or pin a compatible Chrome/ChromeDriver pair. If network access is available, remove an unnecessary executable override and let Selenium Manager resolve the driver. - Launch Chrome outside Selenium. Run the installed Chrome binary under the same user account and environment as the test. If Chrome itself exits, Selenium cannot fix the underlying issue. On Linux, verify permissions and required runtime libraries. Chrome’s guidance identifies running Chrome as root as a common startup crash cause; do not run it as root (ChromeDriver: Chrome doesn’t start).
- Read ChromeDriver logs. Capture logs from the service when a session fails to start. They can help distinguish a driver/browser mismatch from Chrome exiting, a permissions issue, or a profile lock. Consult Selenium’s Service documentation for configuring the local driver service and its logs (Selenium Service documentation).
- Resolve profile-lock errors. If Chrome reports that the user data directory is already in use, stop sharing that profile. Remove the custom profile argument to use ChromeDriver’s temporary profile, or assign a distinct existing parent directory/path for each live worker.
- Remove shared port assumptions. Search options and launch scripts for a fixed remote debugging port or a single hard-coded driver service port reused by every worker. Remove it unless your infrastructure assigns unique ports per session.
- Reduce load or distribute it. If failures appear only when many browsers start together, lower
max_workersand observe whether startup stabilizes. If the needed concurrency exceeds host capacity, move sessions to Grid nodes and configure their session limits. - Check proxy and firewall access. Selenium Manager may need to reach browser-driver metadata endpoints to resolve and download a driver. Configure its proxy for your environment or provision a controlled driver path if corporate network rules block those requests (Selenium Manager documentation).
DevToolsActivePort: what to check
DevToolsActivePort commonly appears when Chrome exits before ChromeDriver can establish its debugging connection. Treat it as a symptom, not as proof that a port needs to be assigned manually. First test Chrome directly under the same account, then inspect the ChromeDriver log, profile arguments, Linux permissions, and runtime libraries. If you supplied a custom profile, confirm that no other worker is using it. On Linux, running Chrome as root is a documented crash cause. ChromeDriver’s guidance describes --no-sandbox as unsupported and highly discouraged, so do not treat it as a routine concurrency fix (ChromeDriver: Chrome doesn’t start).
Or skip the browser setup
If your task is to capture website screenshots rather than test browser interactions, ScreenshotNeo provides a screenshot API and MCP server. A single GET request returns a PNG, JPEG, WebP, or PDF; the API’s other parameter names also work, which can simplify switching from another screenshot service. See the ScreenshotNeo API documentation for options.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpScreenshotNeo accepts cookie and consent banners like a visitor and removes more than 60 known consent platforms, newsletter popups, and chat widgets before capture; each of those steps can be turned off. Bot checks and CAPTCHAs, blank pages, timeouts, failed loads, and cache hits are not billed, and responses identify the page verdict and billing status in headers. Its MCP server provides take_screenshot, get_page_info, and capture_pdf for AI agents using Claude, Cursor, or other MCP clients. The free plan includes 1,000 shots a month with no card; paid plans start at $5 for 3,000 shots.
Sign up for 1,000 free screenshots a month, with no card required.
Frequently Asked Questions
Does Selenium run Chrome sessions in parallel automatically?
No. Your test runner or application must schedule separate WebDriver sessions as concurrent work.
Can I reuse one Chrome profile across separate test runs?
A profile may be reused sequentially if your test setup manages it safely; it must not be active in multiple Chrome sessions at once.
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 →Can I use Selenium Grid with ChromeDriver?
Yes. Grid provides remote WebDriver sessions, while nodes start the browser and driver for the sessions they accept.
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.
