Some links on this page are affiliate links: if you buy through them we may earn a commission, at no extra cost to you.
A Selenium timeout is not one failure with one fix. First identify the operation that exceeded its deadline: browser navigation, element synchronization, asynchronous JavaScript, or the remote WebDriver/Grid connection. Then change the timeout owned by that layer and investigate the component that is actually slow. Increasing every timeout usually makes a test suite slower without repairing a server, browser driver, proxy, Grid node, or CI bottleneck.
Identify which timeout you are seeing
Save the complete exception, stack trace, timestamp, session ID, browser and driver versions, and the command that was running. The operation in the message is often more useful than the word TimeoutException.
| Symptom or operation | Timeout category | First things to inspect |
|---|---|---|
driver.get() or navigation does not return |
WebDriver page-load timeout | Page-load strategy, redirects, blocking resources, endpoint performance, and whether the test needs a complete load |
| An element lookup fails before the element exists | Implicit wait or an explicit wait around a condition | Locator, application state, and whether an explicit condition is more appropriate |
WebDriverWait expires |
Explicit wait timeout | Expected condition, UI state, application errors, and locator correctness |
executeAsyncScript or execute_async_script does not call its callback |
Script timeout | Callback completion and the session’s script-timeout value |
| Remote read timeout, connection reset, or delayed session creation | Client transport, Grid, proxy/load balancer, CI, or test-framework deadline | Which component emitted the error and the deadline at every network hop |
These are separate settings. Selenium’s browser-options documentation lists new-session defaults of 300,000 milliseconds (5 minutes) for page load, 30,000 milliseconds for asynchronous scripts, and 0 milliseconds for implicit waits. Those are WebDriver session defaults documented by the Selenium Project in 2026, not universal HTTP or Grid deadlines and not recommended values for every site (Browser Options).
The Tool Desk
Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Set a measured page-load timeout
Use a page-load timeout when the navigation command itself is the slow operation. Choose a budget from observed response times and the test’s overall deadline; do not copy an arbitrary 30-, 60-, or 120-second value. Keep it at or below an appropriate outer client or CI deadline where possible, otherwise an intermediary can terminate the command before WebDriver reports its own timeout.
Java (Selenium 4)
Selenium 4 uses Duration, rather than the older (long, TimeUnit) form:
import java.time.Duration;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
WebDriver driver = new ChromeDriver();
driver.manage().timeouts().pageLoadTimeout(Duration.ofSeconds(45));
driver.get("https://example.com");The Java API documents this timeout as the limit for loading a page (Java WebDriver.Timeouts API). Always quit the driver in a finally block in production test code.
Python
from selenium import webdriver
options = webdriver.ChromeOptions()
driver = webdriver.Chrome(options=options)
try:
driver.set_page_load_timeout(45) # seconds
driver.get("https://example.com")
finally:
driver.quit()Python’s timeout setters use seconds. Confirm the behavior of the Selenium binding installed in your environment against its API documentation (Python timeouts API).
PC 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 & 11Outdated 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 matchChoose the page-load strategy deliberately
The strategy changes when navigation is considered complete:
| Strategy | Navigation waits for | Synchronization consequence |
|---|---|---|
normal |
The browser’s load event |
Most complete initial navigation, but potentially the longest wait |
eager |
DOMContentLoaded |
Returns earlier; images and other resources may still load |
none |
No page-readiness event | Returns immediately; every required application state needs an explicit wait |
For example, in Java:
ChromeOptions options = new ChromeOptions();
options.setPageLoadStrategy("eager");
WebDriver driver = new ChromeDriver(options);In Python:
from selenium import webdriver
options = webdriver.ChromeOptions()
options.page_load_strategy = "eager"
driver = webdriver.Chrome(options=options)eager or none does not make a single-page application ready. Client-side requests and rendering can continue after the navigation call returns. Wait for the state your next action requires.
Synchronize dynamic pages with explicit conditions
An explicit wait polls for a meaningful condition, such as visibility, text, URL, or a custom completion signal. This is more reliable than a fixed sleep: Selenium notes that a sleep can be too short on a slow run and waste time on a fast one. Selenium’s official waiting guidance states, “Warning: Do not mix implicit and explicit waits” (Waiting Strategies).
Java condition example
import java.time.Duration;
import org.openqa.selenium.By;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(20));
driver.get("https://example.com/dashboard");
wait.until(ExpectedConditions.visibilityOfElementLocated(
By.cssSelector("[data-testid='dashboard-ready']")));
wait.until(ExpectedConditions.textToBePresentInElementLocated(
By.cssSelector("h1"), "Dashboard"));Python condition example
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
wait = WebDriverWait(driver, 20)
driver.get("https://example.com/dashboard")
wait.until(EC.visibility_of_element_located(
(By.CSS_SELECTOR, "[data-testid='dashboard-ready']")))
wait.until(EC.text_to_be_present_in_element(
(By.CSS_SELECTOR, "h1"), "Dashboard"))Use an application-specific marker when possible: a successful API result rendered in the page, an enabled button, a URL change, or a status element that changes from “Loading” to “Ready.” Do not use document.readyState == complete as proof that asynchronous work in a single-page application has finished.
Quick wins for a faster PC:
Scan for outdated or missing drivers - takes under a minuteDriver Scan →Repair Windows errors before they cause bigger problemsFix Now →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Implicit waits: keep their role narrow
An implicit wait applies to element-location calls. It does not extend page navigation and does not wait for arbitrary JavaScript. If your suite uses explicit waits, set the implicit wait to zero and make synchronization explicit:
# Python
driver.implicitly_wait(0)Mixing a long implicit wait with explicit polling can produce unpredictable total durations because each element lookup inside the explicit wait can consume part of the implicit budget.
Configure asynchronous-script timeouts separately
An asynchronous script must invoke Selenium’s supplied callback. If it does not, the script timeout expires even when the page itself loaded successfully.
Rank #3
// Java
driver.manage().timeouts().scriptTimeout(Duration.ofSeconds(30));
Object result = ((JavascriptExecutor) driver).executeAsyncScript(
"const done = arguments[arguments.length - 1];" +
"fetch('/health').then(r => r.json()).then(done).catch(done);");# Python
driver.set_script_timeout(30)
result = driver.execute_async_script("""
const done = arguments[arguments.length - 1];
fetch('/health').then(r => r.json()).then(done).catch(done);
""")Check that every success and error path calls the callback exactly once. A server request that hangs, a rejected promise that is never handled, or a callback hidden behind a conditional can all look like a Selenium script timeout.
Recommended Free Tools
Trace remote WebDriver, Grid, and CI deadlines
For a remote run, map the complete path: test client → WebDriver endpoint or Grid → browser driver and browser → application. Add any corporate proxy, load balancer, and CI/test-framework deadline to that map. A SeleniumConf 2023 deployment presentation demonstrates how multiple timeout layers can interact, but its example values describe that deployment and are not current universal Grid defaults (Selenium Grid Deployment Alternatives).
When only Grid runs fail
- Check whether session creation is waiting for an available slot.
- Inspect node health, browser/driver compatibility, CPU, memory, and concurrent-session load.
- Verify that the command reaches the node and that the node can reach the application.
- Compare local and remote command-response latency and proxy routes.
- Check load-balancer idle/read timeouts and CI or framework command deadlines.
Use logs from the client, Grid/router, node, browser driver, and browser. A client-side read timeout means the client did not receive a response within its transport limit; it is not evidence that the page-load timeout was reached.
Investigate the originating server or network
- Reproduce the target URL outside Selenium with an HTTP client and record DNS, TLS, redirect, time-to-first-byte, and total time.
- Review application, web-server, proxy, and load-balancer logs for the same timestamp and request ID.
- Capture browser-driver and Selenium logs, including the command that stalled.
- Compare the same test locally, from the CI runner, and from the Grid node.
- In restricted environments, verify DNS, certificates, firewall rules, and proxy configuration. Selenium’s options guidance describes proxies as useful for traffic capture, backend mocking, and complex corporate networks (Browser Options).
A larger timeout only permits a slow operation to run longer. It cannot repair a failed route, overloaded application, browser-driver defect, or unavailable Grid node. Selenium’s troubleshooting documentation calls poor synchronization the most common Selenium-related error and notes that underlying drivers can cause problems (Troubleshooting Assistance).
Performance and reliability practices
- Set one measured page-load budget per application or test class, not a suite-wide extreme value.
- Prefer
eageronly when the test can explicitly wait for all state it needs; usenonefor specialized flows where navigation itself is not the synchronization point. - Wait on stable selectors such as
data-testid, not animation timing or incidental CSS. - Record timeout category, URL, operation, elapsed time, browser, driver, Grid node, and request correlation ID.
- Retry only transient infrastructure failures, with a bounded retry count; do not retry assertion or locator errors to conceal a broken test.
- Keep browser, driver, Selenium binding, and Grid versions compatible and upgrade them deliberately.
- Ensure outer deadlines exceed the intended WebDriver budget by enough to collect logs and clean up, while still failing promptly.
Or skip the browser setup
If your goal is a static visual capture rather than interaction, ScreenshotNeo makes one GET request for a PNG, JPEG, WebP, or PDF. Its API accepts the consent banner before capture and removes more than 60 known consent platforms, newsletter popups, and chat widgets; 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 provides an MCP server with take_screenshot, get_page_info, and capture_pdf for Claude, Cursor, and other MCP clients.
Free tools Windows power users keep installed
One-click scans. No signup required.
For a direct capture, see the ScreenshotNeo API documentation:
Rank #4
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}`);ScreenshotNeo includes full-page and element captures, device presets and custom viewports, retina scale, dark mode, PDFs, HTML/CSS rendering, custom JavaScript and headers, cookies, user agents, proxy-style blocking controls, waits, geolocation, caching, signed links, asynchronous webhooks, bulk capture of up to 100 URLs per call, usage information, and an OpenAPI specification. Every feature is on every plan. The Free plan includes 1,000 shots a month with no card; paid plans start at $5 for 3,000 shots. Create a free ScreenshotNeo account.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Common failures and targeted fixes
“Timed out receiving message from renderer” during navigation
Inspect page-load strategy, large or blocked resources, redirects, browser CPU, and driver logs. Test the URL from the same machine; then choose a measured page-load budget or an earlier strategy plus an explicit readiness condition.
WebDriverWait expires even though the page loaded
The condition may describe the wrong state, selector, frame, window, or application error. Capture a screenshot and DOM at expiry, switch to the correct frame/window, and wait for the actual success marker.
Element is found intermittently
Replace a sleep with a visibility, presence, clickability, text, or URL condition. Check for stale elements caused by re-rendering and avoid combining long implicit waits with explicit waits.
Remote command read timeout
Identify the emitting client or proxy. Compare its read/idle deadline with Grid, node, browser, and CI deadlines; inspect connection resets, queue time, and node logs before changing WebDriver page-load settings.
Session creation times out
Check Grid capacity, node registration, browser-driver startup, container resources, routing, and load-balancer limits. A page-load timeout cannot fix a session that was never allocated.
FAQ
Does implicit wait increase Selenium’s page-load timeout?
No. Implicit wait affects element-location calls only. Navigation uses the page-load timeout.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Should I always use eager?
No. It returns before the load event, so use it only when explicit conditions cover the resources and UI state your test needs.
Why does a timeout appear only in CI?
CI may have a different network route, proxy, DNS, resource limit, Grid queue, browser version, or outer command deadline. Compare evidence from each layer rather than assuming the application is universally slower.
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.
