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 minuteHeadless Chrome usually has not failed to load the document when Selenium cannot find a page element. More often, navigation has finished but JavaScript has not yet created or revealed the element, the locator targets the wrong node, or the element exists but is not interactable. Check the page and element state first, then inspect waits and browser versions; compare headed and headless runs only after those basics.
Why does headless Chrome with Selenium fail to load page elements?
Selenium navigation and application readiness are different things. By default, a navigation command waits for the document’s readyState to reach complete. That state describes document loading; it does not guarantee that a JavaScript application has fetched its data, rendered a particular component, or made that component ready for interaction.
Selenium’s official waiting-strategies documentation puts the distinction plainly: “The readyState only concerns itself with loading assets defined in the HTML, but loaded JavaScript assets often result in changes to the site, and elements that need to be interacted with may not yet be on the page when the code is ready to execute the next Selenium command.” A page can therefore look loaded to the browser while the button or result your script needs is still absent.
There are also several different meanings of “the element failed to load.” It may not be in the DOM; it may be present but hidden or disabled; it may be covered by another element; or Selenium may be looking at the wrong page or the wrong node. Those cases need different fixes. Headless mode is one possible environmental difference to investigate, not a diagnosis by itself.
#1 Best Overall
Start by confirming which page and state Selenium reached
Before changing timeouts or Chrome flags, capture basic evidence immediately after navigation. This small Python example records the current URL, page title and document state, then prints the page source if the target is not found. Replace the URL and selector with the ones from your test.
from selenium import webdriver
from selenium.common.exceptions import NoSuchElementException
from selenium.webdriver.common.by import By
url = "https://example.com"
selector = "#results"
driver = webdriver.Chrome()
try:
driver.get(url)
print("URL:", driver.current_url)
print("Title:", driver.title)
print("Ready state:", driver.execute_script("return document.readyState"))
try:
element = driver.find_element(By.CSS_SELECTOR, selector)
print("Found:", element.tag_name, "displayed:", element.is_displayed())
except NoSuchElementException:
print("Not found yet. Page source follows:")
print(driver.page_source)
finally:
driver.quit()Check that the URL and title identify the page you expected. Authentication redirects, an error page, or an interstitial can make a correct-looking locator fail because the browser is elsewhere. Also inspect browser console errors and earlier actions in the test: a failed click or incomplete login can prevent the application from reaching the state your next lookup assumes.
Wait for the state the next command actually needs
Use an explicit wait tied to the element or condition required by the next action. Presence is enough when you only need to read an element in the DOM. Visibility is appropriate when it must be shown. Clickability is a better condition before clicking, though an overlay or layout change can still interfere at the moment of interaction.
Rank #2
Wait for presence
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, 15)
results = wait.until(
EC.presence_of_element_located((By.CSS_SELECTOR, "#results"))
)Wait for visibility or a usable click target
button = wait.until(
EC.visibility_of_element_located((By.CSS_SELECTOR, "button.submit"))
)
submit = wait.until(
EC.element_to_be_clickable((By.CSS_SELECTOR, "button.submit"))
)
submit.click()The timeout shown here is an example maximum wait, not a guarantee that the page will become ready within that period. Choose a limit that fits the application and test environment, and use the condition’s success or failure to identify what is missing. A longer timeout can help distinguish slow rendering from a permanently unmet condition, but it does not repair a bad locator or a page that never reaches the expected state.
Free tools Windows power users keep installed
One-click scans. No signup required.
Choose waits by required state
| Wait condition | What it establishes | Use it when |
|---|---|---|
| Presence | The matching node is in the DOM. | You need to inspect or read a node, whether or not it is displayed. |
| Visibility | The matching node is present and visible. | The next step depends on seeing or reading displayed content. |
| Clickability | The matching node is visible and enabled according to Selenium’s condition. | You are about to click it; investigate overlays or movement too if the click still fails. |
Set the condition as narrowly as possible around the action that depends on it. A global implicit wait changes how every element lookup behaves, while an explicit wait states what one part of the test needs. Selenium warns that mixing implicit and explicit waits can produce unpredictable elapsed times. Avoid stacking both as a way to make a flaky test “safer.”
Fixed sleeps are also fragile: a short pause may be insufficient on a slow run, while a long pause wastes time on a fast one. A temporary sleep can be a diagnostic experiment to see whether an element eventually appears, but replace it with a condition-based wait in the test.
Classify the element failure before changing the locator
Once the page is right, establish whether the target exists and what state it is in. A “not found” exception points toward DOM presence, page state, timing or locator selection. A node that Selenium finds but cannot interact with is a different problem.
- Not present: Check whether the application has completed the action that creates it, whether it is inside a frame or a different page state, and whether the locator still matches the current markup.
- Present but hidden: Wait for visibility if the application reveals it later. If it is meant to remain hidden, it is not a usable click target.
- Disabled: Determine what prerequisite enables it; waiting longer will not help if the prerequisite never occurs.
- Covered or intercepted: Check for a dialog, banner, loading layer or other overlay that blocks the intended interaction. Wait for the relevant state or handle the overlay as the application requires.
- Outside the viewport or moving: Confirm that the page has settled and that the target is the intended node before interacting.
- Wrong node: A broad selector can match a hidden duplicate, template or unrelated control. Narrow it using stable attributes and verify the selected element’s text, tag and state.
Use a locator that reflects the intended element, not merely a selector that happens to match something. If the markup or the expected page changed, update the locator rather than extending the wait. Selenium’s troubleshooting guidance identifies page state, synchronization, hidden elements and locator problems as causes to check.
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 reinstallCheck waits, page-load strategy and browser versions
Do not treat navigation completion as application readiness
Selenium’s page-load strategy controls which document loading milestone a navigation waits for: normal waits for complete, eager waits for interactive, and none does not wait for a document readiness milestone. These settings can change when navigation returns, but none tells Selenium that a particular application element exists or can be clicked. Keep the strategy separate from the explicit condition for the action you need.
Verify Chrome and ChromeDriver
Record the Chrome version and ChromeDriver version used in the failing run. Selenium’s Chrome guidance says their major versions should match. If several Chrome installations are present, verify which browser binary the driver actually launches; checking a different installed browser does not establish compatibility with the one in the test.
Compare headless and headed runs carefully
If the basic checks pass but the element appears only in a visible browser, compare runs with the same browser version, URL, profile, viewport, network conditions and script. A difference narrows the investigation toward an environment- or rendering-dependent branch; it does not prove that headless mode caused the failure.
Chrome’s headless implementation has changed over time. Chrome 112 introduced unified headless mode using the regular Chrome codebase without displaying platform windows. From Chrome 132.0.6793.0, the older implementation is available separately as chrome-headless-shell. That history can matter when identifying which implementation a setup uses, but it cannot explain an individual missing element without evidence from that run.
Use a diagnostic sequence instead of adding global delays
- Confirm the destination: Log
current_url,titleanddocument.readyState; verify the expected page is open rather than a redirect, error page or interstitial. - Inspect the failure: Record the exception, locator, page source around the target, browser console errors and the result of checking whether the node is present and displayed.
- Wait for the dependency: Add an explicit wait for presence, visibility or clickability according to the next operation, not just for navigation to return.
- Validate the target: Confirm the locator selects the intended node and identify whether it is hidden, disabled, covered or otherwise not ready.
- Review synchronization: Remove fixed sleeps as the permanent strategy and avoid combining implicit and explicit waits.
- Check the stack: Log Chrome and ChromeDriver versions, compare their major versions, and verify the browser binary launched.
- Compare modes: Run headed and headless with other conditions held as constant as possible, then investigate the specific difference you observe.
Do not confuse Chrome’s capture timeout with Selenium waits
Chrome’s command-line --timeout option is a maximum wait in milliseconds before headless capture operations such as --dump-dom, screenshots or PDFs proceed, even if loading is still in progress. That is a Chrome CLI capture setting. It does not replace Selenium’s condition-based wait for a DOM element, visibility or clickability.
Common symptoms and fixes
| Symptom | Likely checks | Next step |
|---|---|---|
| “Page loaded” but element not found | Document state versus delayed JavaScript rendering; expected page and locator. | Confirm the destination, then wait explicitly for the element’s required state. |
| Element found but click fails | Visibility, enabled state, overlay, viewport position and target identity. | Wait for clickability and resolve the condition preventing interaction. |
| Failure is intermittent | Variable application latency, fixed sleeps, mixed wait types, or race conditions. | Wait on the specific state the action depends on and avoid mixed implicit/explicit waits. |
| Headed succeeds; headless fails | Browser binary/version, page/profile/viewport/network differences and environment-dependent page behavior. | Compare equivalent runs and use the observed difference to guide further diagnosis. |
| Timeout grows but lookup still fails | Wrong page, stale locator, hidden or disabled node, unmet application prerequisite. | Inspect page state and locator rather than increasing a global timeout again. |
Or skip the browser setup
If your goal is to obtain a page screenshot rather than test Selenium interactions, ScreenshotNeo offers a one-request screenshot API and an MCP server. It is not a Selenium wait or a substitute for validating that an application element is interactable. For a screenshot-based check, one GET request can capture a URL:
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpSee the ScreenshotNeo API documentation for request options. Before capture, it accepts cookie or consent banners and removes more than 60 known consent platforms, newsletter popups and chat widgets; each of those steps can be turned off. Bot checks or 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 tools for AI agents. The Free plan includes 1,000 shots per month without a card; paid plans start at $5 for 3,000 shots.
Sign up free for 1,000 screenshots a month with no card.
Recommended Free Tools
FAQ
Does document.readyState === "complete" mean the page is ready for Selenium?
No. It describes document loading, not whether a JavaScript-rendered element is present or ready for the next interaction.
Should I add --no-sandbox to fix missing elements?
There is no basis here to treat it as a general fix for elements that fail to appear. Diagnose the page, locator, wait condition and browser stack first.
Does ScreenshotNeo test whether Selenium can click an element?
No. It captures pages; Selenium remains the tool for automating and validating browser interactions.
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.
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 →Repair Windows errors before they cause bigger problemsFix Now →
