How to Scroll to an Element in Selenium?

Selenium is a popular browser automation framework that allows you to control web browsers programmatically. One common task when automating browser testing is to scroll to a specific element on the page before interacting with it.

Here are some methods to scroll to an element in Selenium:

Using JavaScript Executor

The easiest way to scroll to an element is using the JavaScript Executor interface. This allows you to execute JavaScript code to manipulate the browser directly. To scroll to an element, first find the element using one of Selenium's locator strategies like CSS selector or XPath:

element = driver.find_element_by_css_selector(".target-element")

Then pass the element to execute_script() to call the scrollIntoView() function:

driver.execute_script("arguments[0].scrollIntoView()", element)

Here's an example test case to scroll to the last element with class product:

from selenium import webdriver
from import By

driver = webdriver.Chrome()

# Get last product element
element = driver.find_elements(By.CSS_SELECTOR, '.products .product')[-1] 

# Scroll to element
driver.execute_script("arguments[0].scrollIntoView()", element)

This will smoothly scroll the page so the element appears at the top. Some things to note about scrollIntoView():

  • It aligns the element to the top of the visible area, not the exact center.
  • You can pass true as a second parameter to align bottom instead of top.
  • It will scroll in an animated fashion if the browser supports it.

Scrolling Relative to Current Position

If you want to scroll a specific amount from the current position, you can use window.scrollBy():

# Scroll down 250px 
driver.execute_script("window.scrollBy(0, 250)")

To scroll up, use a negative value. This is useful if you want to scroll while loading dynamic content slowly.

Scrolling to Specific Coordinates

Use window.scrollTo() to scroll to an exact (x, y) coordinate on the page:

# Scroll to 500px from top
driver.execute_script("window.scrollTo(0, 500)")

To determine the coordinate of an element, you can use the .getBoundingClientRect() JavaScript method:

rect = driver.execute_script(
  "return arguments[0].getBoundingClientRect();",

x = rect["x"]
y = rect["y"]

# Scroll to element's coordinates 
driver.execute_script(f"window.scrollTo({x}, {y})")

This allows precise scrolling to place the element at a specific position on the screen.

Using Actions Class

Selenium's Actions API allows you to automate advanced pointer and keyboard interactions. To scroll using Actions, first create an action sequence:

from selenium.webdriver import ActionChains

actions = ActionChains(driver)

Then perform the scroll operation:

# Scroll down 500 pixels
actions.move_by_offset(0, 500).perform() 

# Scroll up
actions.move_by_offset(0, -200).perform()

This generates native system scroll events identical to a real user. You can also scroll to an element specifically:


A nice benefit of the Actions API is that it supports chaining multiple interactions together:

         .move_by_offset(0, 100)

This will smoothly scroll while performing other actions.

Scrolling Inside Shadow DOM

For elements inside a shadow DOM, the usual JavaScript scroll methods won't work. You'll need first to get the shadow root, then execute scripts in that context:

# Get shadow root 
shadow_root = driver.execute_script('return arguments[0].shadowRoot', element)

# Scroll in shadow DOM
driver.execute_script("arguments[0].scrollTop = 200", shadow_root)

This allows scrolling elements even if they are detached from the main document.

Scrolling in Mobile Viewports

When dealing with mobile webpages, the viewport size is smaller than the full page content. To scroll in a mobile viewport, set the window size before scrolling:

driver.set_window_size(360, 640) # Mobile size

# Scroll 100 pixels down
driver.execute_script("window.scrollBy(0, 100)")

This will properly scroll the shrunken viewport as a mobile user would. Make sure to size the window back to full screen if needed afterwards.

Handling Scrollable Elements

For scrollable elements like <div> containers with overflow, you can scroll them like this:

# Get scrollable element
scrollable = driver.find_element_by_css_selector(".scrollable") 

# Scroll 300px down inside element
  "arguments[0].scrollTop = arguments[0].scrollTop + 300;", 

This works for any element with overflow: auto or overflow: scroll applied.

Scrolling Multipage Articles

For articles split across multiple pages, you may want to automate scrolling through each page. To keep scrolling until a “Next Page” link appears:

while True:

    "window.scrollTo(0, document.body.scrollHeight);"
    next_button = driver.find_element(By.LINK_TEXT, "Next Page")
  except NoSuchElementException:
    pass # Keep scrolling if next button not found yet

This continuously scrolls to the bottom until it's able to find and click the next button.

Scrolling in a Headless Browser

All scrolling methods work the same in headless mode. The only difference is that headless Chrome doesn't support smooth scrolling animations. The scrolling will happen instantly instead. Everything else works correctly to scroll the page or elements.

Common Scrolling Issues

Here are some common issues faced when scrolling pages in Selenium:

  • ElementNotInteractableException – This happens if you try to scroll an element that is not visible or enabled. You may need first to scroll a parent container into view.
  • StaleElementReferenceException – If the page layout changes after scrolling, previously located elements can go stale. You may need to re-query the element after scrolling.
  • TimeoutException – Slow loading pages can cause timeouts if you don't wait for scrolling to complete. Use explicit waits to ensure scrolling finishes.
  • Javascript errors – Syntax errors or mistakes in your JavaScript code will lead to generic JavascriptException errors in Selenium. Double check your JavaScript code is valid.
  • Not scrolling inside iframes – You can't directly scroll cross-domain iframes. You'll need to switch into the frame context before scrolling.

Scrolling Best Practices

Here are some tips to ensure successful scrolling:

  • Prefer CSS selectors over XPath to locate elements, as they perform better and are less prone to stale elements.
  • Always wait for the page to finish loading before attempting to scroll.
  • Use explicit waits after scrolling actions to allow time for pages to update.
  • Scroll incrementally and check for changes rather than large amounts in one shot.
  • Catch stale element exceptions and retry finding the element after scrolling.
  • For large scrolling regions, scroll in a loop until you reach the desired element.


Scrolling is essential to handle dynamic pages and large data sets when testing modern web and mobile apps. Selenium provides many flexible options to scroll to elements or positions, including:

  • execute_script() to run scroll JavaScript
  • ActionChains to generate UI scroll events
  • Managing scrollable containers and iframes
  • Smart waits and retries when dealing with delays

Robust scrolling methods open up many possibilities for automated browser testing. Elements that were previously hard to access can now be scrolled into view for easy interaction.

With the above techniques, you should be able to handle any scroll scenario that comes up in your Selenium tests. Scrolling well will improve reliability and prevent flakey test failures due to elements going out of view.

John Rooney

John Rooney

John Watson Rooney, a self-taught Python developer and content creator with a focus on web scraping, APIs, and automation. I love sharing my knowledge and expertise through my YouTube channel, My channel caters to all levels of developers, from beginners looking to get started in web scraping to experienced programmers seeking to advance their skills with modern techniques. I have worked in the e-commerce sector for many years, gaining extensive real-world experience in data handling, API integrations, and project management. I am passionate about teaching others and simplifying complex concepts to make them more accessible to a wider audience. In addition to my YouTube channel, I also maintain a personal website where I share my coding projects and other related content.

We will be happy to hear your thoughts

      Leave a reply

      Compare items
      • Total (0)