Staleelementreferenceexception on Python Selenium

python

selenium

webdriverwait

staleelementreferenceexception

byNikita Barsukov·Mar 7, 2025

To overcome StaleElementReferenceException, interact with web elements when they're in a stable state on the webpage. This error often arises if the web element alters or refreshes since your code had located it. Implement explicit waits to pause your code until the web element is ready for interaction:

from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By

element = WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, "element_id")))
element.click()  # The element has been tamed; interaction is safe.

Essentially, this code waits up to 10 seconds for the element to become available, ensuring reliable interaction while warding off the StaleElementReferenceException gremlin.

Recognizing the enemy: Origins of StaleElementReferenceException

Before we begin waging battle against StaleElementReferenceException, let's understand its genesis. The exception primarily crops up when:

Dynamic updates: The web element has been removed or altered dynamically.
Refreshed elements: The web element has been propagated afresh, a common phenomenon in lists or tables that refresh periodically.
Page navigation or AJAX calls: The web element is detached from the DOM after some operations like page navigations or AJAX calls.

At the root, when the web element doesn't exist in the current browser DOM structure that Selenium WebDriver operates upon, it considers the element as stale.

Advanced approaches: WebDriverWait and try-except block

Put WebDriverWait to work, using select timeout conditions, to reduce instances of stale elements. For instance, element_to_be_clickable or visibility_of_element_located:

element = WebDriverWait(driver, 10).until(
    EC.element_to_be_clickable((By.ID, "interactive_element_id"))
)
element.click()

Complement WebDriverWait with a strategic use of a try-except block. You can effectively combat the staleness issue and take necessary alternative actions:

from selenium.common.exceptions import StaleElementReferenceException

try:
    element = WebDriverWait(driver, 10).until(
        EC.element_to_be_clickable((By.ID, "interactive_element_id"))
    )
    element.click()
except StaleElementReferenceException:
    # Rekindle the search flame, the stale element wanted a coffee break! 
    driver.refresh()
    # Implement retry logic here or handle error in a suitable way

Dealing with tricksters: Element iteration and re-finding

Iterating over a list of elements may present staleness. You can best this by re-locating the elements at each iteration:

elements = driver.find_elements_by_class_name("dynamic-item")  # "catch them all!"
for i in range(len(elements)):
    elements = driver.find_elements_by_class_name("dynamic-item")  # Time to play the hide and seek game again!
    elements[i].click()  # You can run, but you can't hide! 
    # Handle the aftermath of the click before the next round

Additional lines of defense for robust code

Consider a few others preventative measures to drastically reduce StaleElementReferenceException:

Implicit waits: Set global timeouts to improve the overall stability of your Selenium script. It's generally considered a last resort strategy over the preferred explicit waits, but it's a useful sheriff in town!
```
driver.implicitly_wait(10)  # "Patience is a virtue...for up to 10 seconds"
```
Refreshing the driver: Before any critical interaction, or at strategic points in your script, consider giving your page a refreshing makeover.
```
driver.refresh()  # Everyone enjoys a little spa day!
```
Page Object Model: With well-structured Page Object Models in place, you can abstract away the details of re-finding elements and handle stale element occurrences centrally.

Smoothen your traversal with pro-tips

Reinitializing instances

Sometimes wiping the slate clean by reinitializing objects engaging with the DOM (like WebDriver or ActionChains instances) ensures they stay in sync with the current page state.

Timing your act

Ensure timing of actions corresponds with the page state. If your action initiates too early, the page might not be ready. Enforcing a short wait or synchronizing code with on-screen transitions could solve this issue.

Spot the patterns

Certain tools such as ActionChains can be less patient with stale elements due to their tendency to carry out a sequence of actions, therefore throwing a StaleElementReferenceException. When this happens, replacing the ActionChains instance might save the day!

explain-codes / Python / Staleelementreferenceexception on Python Selenium

Linked

Stale element reference: element is not attached to the page document



Test if an element is present using Selenium WebDriver



Checking if an element exists with Python Selenium



Wait until page is loaded with Selenium WebDriver for Python



How can I inspect disappearing element in a browser?

