The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Some links on this page are affiliate links: if you buy through them we may earn a commission, at no extra cost to you.
In Selenium Python, driver.get(url) already waits for navigation according to the session’s page-load strategy. With the default normal strategy, it waits for the document’s complete state. That does not guarantee that a JavaScript application has finished rendering the content you need. For dynamic pages, use WebDriverWait to wait for the specific element or state required by your next action.
What Selenium waits for when you call get()
A basic navigation needs no extra sleep:
from selenium import webdriver
driver = webdriver.Chrome()
driver.get("https://example.com")
# get() returns according to the configured page-load strategy.
With Selenium’s default normal strategy, navigation waits for the document’s complete readiness state. The Selenium waiting guide explains that navigation commands wait for a specific readyState value determined by the page-load strategy. Document readiness concerns the page and assets represented in the HTML; JavaScript can still add or alter elements after navigation returns. A single-page application may therefore be usable only after a later application-specific event.
Think of navigation readiness and application readiness as separate questions: “Has the browser reached the configured document state?” and “Is the thing my script needs ready?” get() answers the first according to the strategy. A targeted wait answers the second.
Recommended Free Tools
Wait for the condition your next step needs
Use an explicit wait when you need a particular element or state. WebDriverWait polls a condition until it succeeds or the timeout expires. The expected condition should match the action, rather than being a generic delay.
#1 Best Overall
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
driver = webdriver.Chrome()
driver.get("https://example.com")
wait = WebDriverWait(driver, 15)
results = wait.until(
EC.visibility_of_element_located(
(By.CSS_SELECTOR, "[data-testid='results']")
)
)
results.click()
The 15-second value is the maximum this wait will poll before timing out; it is not a promise that Selenium will pause for exactly that long. If the condition becomes true sooner, the wait returns then.
Choose an expected condition by purpose
presence_of_element_located: the element needs to exist in the DOM; it need not be visible.visibility_of_element_located: the element needs to exist and be visible, for example before reading text a user should see.element_to_be_clickable: use when the next step is clicking and you need Selenium to wait for a clickable element.
Other useful explicit-wait targets include a page title, the current URL, or a custom predicate representing an application state. The right condition depends on what must be true before the next line of your script can safely run.
Wait after actions as well as navigation
A click or form submission can trigger navigation or update the current page without a new driver.get() call. Do not assume the action itself proves the resulting state is ready. Follow it with a wait for a destination URL, a changed title, a confirmation element, or the content that the next step uses. This is especially important for AJAX updates and client-rendered transitions.
Set a separate limit for navigation
driver.set_page_load_timeout(seconds) sets a ceiling on waiting for page-load completion during navigation. It is not a substitute for waiting for a particular element, nor does it express that an SPA’s data has arrived.
from selenium import webdriver
driver = webdriver.Chrome()
driver.set_page_load_timeout(30)
driver.get("https://example.com/slow-page")
Remove the extra leading space before driver = if copying this snippet into a file; the complete copyable version is:
from selenium import webdriver
driver = webdriver.Chrome()
driver.set_page_load_timeout(30)
driver.get("https://example.com/slow-page")
The Python API describes this value as the number of seconds to wait for page-load completion before an error is thrown. A page-load timeout and an explicit wait fail for different reasons: one limits navigation completion, while the other limits the time to satisfy a condition. Set each only when that distinct limit is useful to your flow.
Choose a page-load strategy only when you need to change navigation behavior
Selenium defines three session-wide strategies. They determine when navigation returns, not whether your application’s asynchronous work is finished.
Free tools Windows power users keep installed
One-click scans. No signup required.
| Strategy | Navigation return point | What to do next |
|---|---|---|
normal |
Waits for complete / the load event. |
Use an explicit wait if the required dynamic content may arrive later. |
eager |
Returns at interactive / DOMContentLoaded. |
Wait explicitly for the element or application state your script needs. |
none |
Does not block WebDriver on document readiness. | Use only with deliberate condition-based waits after navigation. |
In Python, set the strategy when creating the session:
from selenium import webdriver
options = webdriver.ChromeOptions()
options.page_load_strategy = "eager" # "normal", "eager", or "none"
driver = webdriver.Chrome(options=options)
driver.get("https://example.com")
# Navigation may have returned before the application content is ready.
The capability applies to the whole session, so changing it affects navigation throughout that session. An earlier return can let your script begin its own targeted wait sooner, but it also makes that explicit synchronization essential. Strategy choice is not a replacement for condition-based waits after clicks or form submissions.
Explicit waits, implicit waits, and fixed sleeps compared
| Approach | What it waits for | Scope and typical use | Failure behavior |
|---|---|---|---|
| Page-load strategy | A document readiness milestone during navigation. | Session-wide navigation policy. | Navigation may fail to complete within a configured page-load timeout. |
WebDriverWait |
A chosen element condition or predicate. | One stated condition, useful for dynamic page content and transitions. | Raises a timeout exception if the condition does not become true in time. |
implicitly_wait |
Element location. | Global delay applied to element-location calls for the session. | Element lookup still fails if the element is not found before the implicit wait expires. |
time.sleep() |
Nothing about the page; only elapsed time. | Fixed pause, without checking readiness. | May waste time when the page is ready early and still be too short when it is slow. |
Why not combine implicit and explicit waits?
An implicit wait is configured once and affects every element-location call; its default is zero. Selenium warns against mixing implicit and explicit waits because their combined timing can become unpredictable. For dynamic applications, prefer explicit waits tied to each needed state instead of stacking global and condition-specific delays.
For example, an implicit wait can be set with driver.implicitly_wait(5), but that does not mean “wait five seconds for the results panel to become visible.” It applies to element searches generally. If visibility of that panel is the actual requirement, state that directly with an explicit wait.
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 minuteWindows 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 reinstallA practical pattern for a dynamic page
- Create the driver. Use the browser and session options appropriate to your test.
- Set a page-load timeout if navigation needs a ceiling. This controls page-load completion, not application readiness.
- Navigate. Call
driver.get(url)and let the configured strategy govern its return. - Wait for the next real precondition. Use presence, visibility, clickability, title, URL, or a custom predicate according to the next action.
- Act only after the condition succeeds. Keep the returned element from
wait.until()when appropriate, then click, read, or otherwise use it. - Diagnose timeouts from the browser state. Confirm the locator, current frame or window, overlays, and application’s actual ready signal before increasing a timeout.
Troubleshooting waits that time out
The locator does not match the live page
Check the selector against the DOM as it exists after the relevant page transition. A typo, changed attribute, or selector that identifies a different element will keep a correct wait condition false. Verify the element in the browser and make the locator specific to the intended content.
The content is inside an iframe or another window
Selenium searches in its current browsing context. If the target belongs to a frame or a newly opened window, first switch to that context; waiting in the original context cannot find the target there.
An overlay prevents interaction
An element may be present or visible while a modal, consent layer, or other overlay prevents the intended click. Check what covers the target and wait for the overlay to disappear or for the actual clickable state, rather than treating presence as sufficient.
The page changed and the element reference is stale
Client-side updates can replace DOM nodes. If a previously located element is no longer attached to the current DOM, locate it again after the update and wait for the current element’s needed condition.
Do these 3 things before closing this tab:
1Fix the driver behind crashes, sound loss and screen glitches2Clear out junk files and repair common Windows errors3Scan for outdated or missing drivers - takes under a minuteThe wait watches the wrong signal
document.readyState == 'complete' describes document readiness; it does not establish that an SPA’s data request finished or that a particular component rendered. Look for the application’s status indicator, expected result element, changed URL, or another observable signal tied to the operation.
The page-load timeout occurs before your explicit wait
If get() itself exceeds its configured page-load timeout, execution may not reach the following explicit wait. Decide whether the navigation ceiling suits the page and diagnose the slow or hanging navigation separately from the element condition you need afterward.
Or skip the browser setup
If the deliverable is a screenshot rather than browser interaction or Selenium-driven testing, ScreenshotNeo offers a one-GET screenshot API. It is not a drop-in replacement for WebDriver when you need to click through a workflow or assert application behavior. For direct capture, start with this cURL example; see the ScreenshotNeo API documentation for options and setup.
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpEquivalent Python:
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)Equivalent 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}`);ScreenshotNeo accepts cookie or 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, blank pages, timeouts, failed loads, and cache hits are not billed, and response headers identify the page verdict and billing status. Its MCP server provides take_screenshot, get_page_info, and capture_pdf tools for AI agents and MCP clients. The free plan includes 1,000 screenshots per month with no card; paid plans start at $5 for 3,000 shots. Sign up for the free plan.
FAQ
Does Selenium wait automatically when I use driver.get()?
Yes. It waits according to the session’s page-load strategy; with the default normal strategy, the return point is document readiness at complete. That is not a guarantee that later JavaScript-driven application work has finished.
What is the difference between a page-load timeout and an explicit-wait timeout?
A page-load timeout limits navigation completion. An explicit wait limits how long Selenium polls for a chosen condition, such as a visible results element. They control different phases of a script.
Can I use eager with a page that loads content asynchronously?
Yes, but treat its earlier navigation return as a reason to wait explicitly for the asynchronous content your script needs; the strategy does not wait for that content on its own.
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.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
