Infinite Scrolling is a web application behavior in which additional content is dynamically loaded as the user scrolls toward the bottom of a page. Unlike traditional pagination, where users click a Next button to load another page, an infinite-scroll page continuously retrieves and displays more content without requiring a full page navigation.
Infinite scrolling is commonly found in social media feeds, e-commerce product listings, news websites, image galleries, search results, dashboards, and content platforms. In Selenium automation, infinite scrolling requires a combination of WebDriver scrolling techniques, JavaScript execution, explicit waits, element detection, and sometimes network or DOM-based conditions.
Selenium WebDriver provides browser control, while JavaScript can be executed through Selenium's JavascriptExecutor interface. Selenium also provides Actions-based scrolling APIs for scrolling to elements or by a specified amount. :contentReference[oaicite:0]{index=0}
Course Resource: Selenium Training | Register for Course Demo
Infinite scrolling is a user-interface technique where new content is automatically loaded when the user reaches or approaches the bottom of the currently displayed content.
For example, consider an e-commerce application containing 20 products initially. When the user scrolls near the bottom, another set of products may be loaded. The process continues until no more products are available.
Initial Page
|
v
Display Initial Content
|
v
User Scrolls Down
|
v
Bottom / Trigger Point Reached
|
v
Application Requests More Data
|
v
New Content Loaded
|
v
DOM Updated
|
v
User Scrolls Again
|
v
More Content Loaded
|
v
Continue Until No More Content
Infinite scrolling is important because a standard Selenium test may not be able to interact with elements that have not yet been loaded into the DOM or displayed on the page.
| Feature | Infinite Scrolling | Traditional Pagination |
|---|---|---|
| Navigation | Content loads while scrolling | User clicks page numbers or Next |
| Page Navigation | Usually remains on the same page | May navigate between pages |
| Content Loading | Dynamic | Usually page-based |
| Automation | Requires scrolling and synchronization | Usually simpler |
| Common Use | Feeds, galleries, product lists | Search results, reports, tables |
| Stopping Condition | No more content or end marker | Last page reached |
Many infinite-scroll applications monitor the user's scroll position. When the user approaches a configured threshold, the application requests additional data from the server and inserts the new content into the page.
Browser
|
| Scroll Event
v
JavaScript Application
|
| Detect Bottom / Threshold
v
API Request
|
v
Server
|
v
New Data
|
v
DOM Updated
|
v
Additional Elements Displayed
Because the content is dynamic, Selenium automation should synchronize with the application rather than relying only on fixed sleep intervals.
Selenium WebDriver controls the browser and provides APIs for interacting with web pages and elements. Scrolling can be performed using JavaScript execution, Selenium Actions, element interactions, keyboard actions, or other browser-supported mechanisms. :contentReference[oaicite:1]{index=1}
For infinite scrolling, the most commonly used approaches are:
Selenium's Java implementation provides the JavascriptExecutor interface for executing JavaScript in the currently selected browsing context. This makes it possible to execute browser-side scrolling commands from Selenium. :contentReference[oaicite:2]{index=2}
JavascriptExecutor js = (JavascriptExecutor) driver;
js.executeScript("window.scrollTo(0, document.body.scrollHeight);");
The script scrolls the browser viewport to the current bottom of the document.
A basic technique is to scroll directly to the current document height.
JavascriptExecutor js = (JavascriptExecutor) driver;
js.executeScript(
"window.scrollTo(0, document.body.scrollHeight);"
);
This is useful when the application loads additional content whenever the viewport reaches the bottom.
Instead of moving directly to the bottom, Selenium can execute JavaScript that scrolls by a specified number of pixels.
JavascriptExecutor js = (JavascriptExecutor) driver;
js.executeScript("window.scrollBy(0, 500);");
Here, the page is moved vertically by approximately 500 pixels.
Scrolling to the top can also be useful during navigation and validation.
JavascriptExecutor js = (JavascriptExecutor) driver;
js.executeScript("window.scrollTo(0, 0);");
A simple infinite-scroll automation strategy is to repeatedly scroll to the bottom until the page height stops changing.
JavascriptExecutor js = (JavascriptExecutor) driver;
long previousHeight = (Long) js.executeScript(
"return document.body.scrollHeight"
);
while (true) {
js.executeScript(
"window.scrollTo(0, document.body.scrollHeight);"
);
Thread.sleep(2000);
long currentHeight = (Long) js.executeScript(
"return document.body.scrollHeight"
);
if (currentHeight == previousHeight) {
break;
}
previousHeight = currentHeight;
}
The basic logic is:
Get Initial Height
|
v
Scroll to Bottom
|
v
Wait for New Content
|
v
Get New Height
|
v
Compare Heights
/ \
Same Different
| |
Stop Scroll Again
document.body.scrollHeight represents the total scrollable height of the document body. Comparing its value before and after scrolling can help determine whether the page grew after additional content was loaded.
long height = (Long) js.executeScript(
"return document.body.scrollHeight;"
);
If the height increases after scrolling, it can indicate that additional content has been appended. If it remains unchanged, it may indicate that no additional content was loaded.
import java.time.Duration;
import org.openqa.selenium.JavascriptExecutor;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class InfiniteScrollTest {
public static void main(String[] args) throws InterruptedException {
WebDriver driver = new ChromeDriver();
try {
driver.manage().window().maximize();
driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(5));
driver.get("https://example.com");
JavascriptExecutor js = (JavascriptExecutor) driver;
long previousHeight = (Long) js.executeScript(
"return document.body.scrollHeight;"
);
while (true) {
js.executeScript(
"window.scrollTo(0, document.body.scrollHeight);"
);
Thread.sleep(2000);
long currentHeight = (Long) js.executeScript(
"return document.body.scrollHeight;"
);
if (currentHeight == previousHeight) {
break;
}
previousHeight = currentHeight;
}
System.out.println("Infinite scrolling completed.");
} finally {
driver.quit();
}
}
}
Thread.sleep() pauses the Java thread for a fixed amount of time. Although it can be useful for demonstrating a basic infinite-scroll technique, it is generally less reliable than condition-based synchronization because content may load faster or slower depending on network and application behavior.
For production automation, explicit waits or application-specific conditions are usually preferable.
Explicit waits allow the test to wait for a meaningful condition instead of always waiting for a fixed duration.
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
wait.until(driver ->
((JavascriptExecutor) driver).executeScript(
"return document.readyState"
).equals("complete")
);
For infinite scrolling, the best wait condition depends on how the application signals that new content has loaded. Possible conditions include:
Suppose products are represented by elements with a class such as .product-card. The automation can record the number of products before scrolling and wait for that count to increase.
int oldCount = driver.findElements(
By.cssSelector(".product-card")
).size();
js.executeScript(
"window.scrollTo(0, document.body.scrollHeight);"
);
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
wait.until(driver ->
driver.findElements(
By.cssSelector(".product-card")
).size() > oldCount
);
This approach is often more meaningful than waiting for a fixed number of seconds because it waits for the actual content condition.
Another practical technique is to continue scrolling while the number of loaded elements increases.
int previousCount = 0;
while (true) {
int currentCount = driver.findElements(
By.cssSelector(".product-card")
).size();
if (currentCount == previousCount) {
break;
}
previousCount = currentCount;
js.executeScript(
"window.scrollTo(0, document.body.scrollHeight);"
);
Thread.sleep(1500);
}
The selector should be replaced with the locator used by the actual application.
Many applications display a loading spinner while additional content is being retrieved.
By spinner = By.cssSelector(".loading-spinner");
js.executeScript(
"window.scrollTo(0, document.body.scrollHeight);"
);
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
wait.until(ExpectedConditions.invisibilityOfElementLocated(spinner));
This technique can be effective when the application's loading indicator reliably appears and disappears around each content request.
Some applications display a message such as No more results, You've reached the end, or No more products after all content has been loaded.
By endMessage = By.xpath(
"//*[contains(text(),'No more results')]"
);
while (driver.findElements(endMessage).isEmpty()) {
js.executeScript(
"window.scrollTo(0, document.body.scrollHeight);"
);
Thread.sleep(1500);
}
When the end-of-content element becomes available, the loop can stop.
A test should not always depend exclusively on page height or end-of-content detection. A maximum iteration limit can prevent an accidental infinite loop when the application behaves unexpectedly.
int maxScrolls = 20;
for (int i = 0; i < maxScrolls; i++) {
js.executeScript(
"window.scrollTo(0, document.body.scrollHeight);"
);
Thread.sleep(1500);
System.out.println("Scroll iteration: " + (i + 1));
}
A maximum iteration limit is especially useful as a safety mechanism in automated tests.
long previousHeight = 0;
int maxAttempts = 20;
for (int i = 0; i < maxAttempts; i++) {
long currentHeight = (Long) js.executeScript(
"return document.body.scrollHeight;"
);
if (currentHeight == previousHeight) {
break;
}
previousHeight = currentHeight;
js.executeScript(
"window.scrollTo(0, document.body.scrollHeight);"
);
Thread.sleep(1500);
}
This approach provides both a normal stopping condition and a maximum safety limit.
Selenium also provides scrolling capabilities through the Actions API. For example, Selenium supports scrolling to an element and scrolling by a specified amount. :contentReference[oaicite:3]{index=3}
WebElement element = driver.findElement(
By.cssSelector(".target-element")
);
new Actions(driver)
.scrollToElement(element)
.perform();
This approach is useful when the automation needs to bring a particular element into the viewport rather than scrolling the entire document to the bottom.
new Actions(driver)
.scrollByAmount(0, 600)
.perform();
Scrolling by a controlled amount can be useful when the page loads content progressively based on smaller scroll movements.
If the target element is known, scrolling directly to that element can be simpler than repeatedly scrolling the page.
WebElement target = driver.findElement(
By.id("targetElement")
);
new Actions(driver)
.scrollToElement(target)
.perform();
target.click();
Not every infinite-scroll page uses the browser's main document. Some applications have a scrollable container such as a product panel, chat window, table, or dashboard section.
WebElement container = driver.findElement(
By.cssSelector(".scroll-container")
);
js.executeScript(
"arguments[0].scrollTop = arguments[0].scrollHeight;",
container
);
Here, the scroll is applied to the selected container instead of the entire page.
| Window Scroll | Container Scroll |
|---|---|
| Scrolls the main document | Scrolls a specific element |
| Uses document/body height | Uses container scrollHeight |
| Common on feed pages | Common in dashboards and panels |
| Example: window.scrollTo() | Example: element.scrollTop |
Before automating infinite scrolling, determine whether the page itself scrolls or whether a specific container handles scrolling.
WebElement container = driver.findElement(
By.cssSelector(".scroll-container")
);
Long scrollHeight = (Long) js.executeScript(
"return arguments[0].scrollHeight;",
container
);
Long clientHeight = (Long) js.executeScript(
"return arguments[0].clientHeight;",
container
);
System.out.println("Scroll Height: " + scrollHeight);
System.out.println("Visible Height: " + clientHeight);
There are several possible indicators that more content is available:
E-commerce websites frequently use dynamic product loading. Selenium can scroll repeatedly and collect product elements.
By products = By.cssSelector(".product-card");
int previousCount = 0;
while (true) {
int currentCount = driver.findElements(products).size();
System.out.println(
"Products loaded: " + currentCount
);
if (currentCount == previousCount) {
break;
}
previousCount = currentCount;
js.executeScript(
"window.scrollTo(0, document.body.scrollHeight);"
);
Thread.sleep(1500);
}
After all products have been loaded, Selenium can retrieve the elements and extract information such as product name, price, rating, and availability.
List<WebElement> products = driver.findElements(
By.cssSelector(".product-card")
);
for (WebElement product : products) {
String name = product.findElement(
By.cssSelector(".product-name")
).getText();
String price = product.findElement(
By.cssSelector(".price")
).getText();
System.out.println(
name + " - " + price
);
}
Social media feeds are common examples of infinite scrolling. New posts may be inserted as the user reaches the bottom.
for (int i = 0; i < 10; i++) {
js.executeScript(
"window.scrollTo(0, document.body.scrollHeight);"
);
Thread.sleep(2000);
List<WebElement> posts = driver.findElements(
By.cssSelector(".post")
);
System.out.println(
"Posts loaded: " + posts.size()
);
}
In a real framework, a stronger stopping condition should be used instead of an arbitrary fixed number of iterations.
News applications may dynamically load additional articles as the user scrolls.
By articles = By.cssSelector(".article-card");
int previousCount = 0;
while (true) {
int currentCount = driver.findElements(articles).size();
if (currentCount == previousCount) {
break;
}
previousCount = currentCount;
js.executeScript(
"window.scrollTo(0, document.body.scrollHeight);"
);
Thread.sleep(1500);
}
Image galleries may load additional images when the user reaches the bottom.
By images = By.cssSelector(".gallery-image");
int previousCount = 0;
while (true) {
int currentCount = driver.findElements(images).size();
if (currentCount == previousCount) {
break;
}
previousCount = currentCount;
js.executeScript(
"window.scrollTo(0, document.body.scrollHeight);"
);
Thread.sleep(1200);
}
Lazy loading and infinite scrolling are related but different concepts.
| Lazy Loading | Infinite Scrolling |
|---|---|
| Loads content when needed or near viewport | Continuously loads additional content during scrolling |
| Often used for images | Often used for lists and feeds |
| Can occur without page growth | Usually results in additional content being appended |
| Focuses on deferred loading | Focuses on continuous content loading |
An infinite-scroll page may also contain lazy-loaded images. Selenium may need to scroll through the page so that images become available or visible.
List<WebElement> images = driver.findElements(
By.cssSelector("img")
);
for (WebElement image : images) {
new Actions(driver)
.scrollToElement(image)
.perform();
}
Scrolling alone is not enough for a reliable automated test. The test should verify that the expected content was actually loaded.
List<WebElement> products = driver.findElements(
By.cssSelector(".product-card")
);
Assert.assertTrue(
products.size() > 0,
"No products were loaded."
);
A practical test can continue scrolling until a target product is found.
By product = By.xpath(
"//*[contains(text(),'Laptop')]"
);
boolean found = false;
for (int i = 0; i < 15; i++) {
if (!driver.findElements(product).isEmpty()) {
found = true;
break;
}
js.executeScript(
"window.scrollTo(0, document.body.scrollHeight);"
);
Thread.sleep(1000);
}
Assert.assertTrue(
found,
"Target product was not found."
);
One of the most useful infinite-scroll automation patterns is to stop scrolling as soon as the target element becomes available.
By target = By.id("target");
boolean found = false;
while (!found) {
List<WebElement> elements =
driver.findElements(target);
if (!elements.isEmpty()) {
found = true;
break;
}
js.executeScript(
"window.scrollTo(0, document.body.scrollHeight);"
);
Thread.sleep(1000);
}
A maximum iteration count should normally be added so that a missing element cannot cause an endless test.
By target = By.id("target");
boolean found = false;
int maxAttempts = 15;
for (int i = 0; i < maxAttempts; i++) {
if (!driver.findElements(target).isEmpty()) {
found = true;
break;
}
js.executeScript(
"window.scrollTo(0, document.body.scrollHeight);"
);
Thread.sleep(1000);
}
Assert.assertTrue(
found,
"Target element was not found after scrolling."
);
Infinite scrolling can dynamically modify the DOM. When new content is inserted, previously located WebElements may become stale.
Instead of storing a WebElement for a long period, it can be safer to locate the element again after the DOM changes.
By product = By.cssSelector(".product-card");
for (int i = 0; i < 10; i++) {
List<WebElement> products =
driver.findElements(product);
System.out.println(
"Current products: " + products.size()
);
js.executeScript(
"window.scrollTo(0, document.body.scrollHeight);"
);
Thread.sleep(1000);
}
If a previously stored element becomes stale, Selenium may throw StaleElementReferenceException. A common strategy is to relocate the element after the DOM has changed.
try {
WebElement element = driver.findElement(
By.id("target")
);
element.click();
} catch (StaleElementReferenceException e) {
WebElement element = driver.findElement(
By.id("target")
);
element.click();
}
The DOM may continuously grow as new content is appended. Therefore, test automation should avoid assumptions that all elements are present immediately after page load.
Page Load
|
v
Initial DOM
|
v
Scroll
|
v
DOM Updated
|
v
New Elements
|
v
Scroll Again
|
v
DOM Updated Again
Synchronization is one of the most important aspects of infinite-scroll automation. The test should wait for the application's state to change rather than using unnecessarily long fixed delays.
long oldHeight = (Long) js.executeScript(
"return document.body.scrollHeight;"
);
js.executeScript(
"window.scrollTo(0, document.body.scrollHeight);"
);
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
wait.until(driver -> {
long newHeight = (Long) js.executeScript(
"return document.body.scrollHeight;"
);
return newHeight > oldHeight;
});
This approach waits until the page becomes taller than it was before scrolling.
Instead of duplicating scrolling logic in every test, a reusable utility method can be created.
public void scrollToBottomUntilEnd(
WebDriver driver
) throws InterruptedException {
JavascriptExecutor js =
(JavascriptExecutor) driver;
long previousHeight = 0;
int maxAttempts = 20;
for (int i = 0; i < maxAttempts; i++) {
long currentHeight = (Long) js.executeScript(
"return document.body.scrollHeight;"
);
if (currentHeight == previousHeight) {
break;
}
previousHeight = currentHeight;
js.executeScript(
"window.scrollTo(0, document.body.scrollHeight);"
);
Thread.sleep(1000);
}
}
public void scrollToElement(
WebDriver driver,
WebElement element) {
JavascriptExecutor js =
(JavascriptExecutor) driver;
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
element
);
}
public void scrollContainerToBottom(
WebDriver driver,
WebElement container) {
JavascriptExecutor js =
(JavascriptExecutor) driver;
js.executeScript(
"arguments[0].scrollTop = arguments[0].scrollHeight;",
container
);
}
Infinite scrolling can be integrated into a Page Object Model framework by placing page-specific scrolling and element methods inside the relevant page class.
public class ProductPage {
WebDriver driver;
By products = By.cssSelector(".product-card");
public ProductPage(WebDriver driver) {
this.driver = driver;
}
public int getProductCount() {
return driver.findElements(products).size();
}
public void scrollToBottom()
throws InterruptedException {
JavascriptExecutor js =
(JavascriptExecutor) driver;
js.executeScript(
"window.scrollTo(0, document.body.scrollHeight);"
);
Thread.sleep(1000);
}
}
public class ProductTest {
WebDriver driver;
ProductPage productPage;
@Test
public void verifyProducts() throws InterruptedException {
productPage = new ProductPage(driver);
int oldCount = productPage.getProductCount();
productPage.scrollToBottom();
int newCount = productPage.getProductCount();
Assert.assertTrue(
newCount >= oldCount
);
}
}
Data Providers can be combined with infinite-scroll tests when multiple search keywords, categories, or target products need to be tested.
@DataProvider(name = "products")
public Object[][] products() {
return new Object[][] {
{"Laptop"},
{"Mobile"},
{"Headphones"}
};
}
@Test(dataProvider = "products")
public void searchProductTest(String product)
throws InterruptedException {
// Search product
// Scroll dynamically
// Find target product
// Validate result
System.out.println(
"Testing product: " + product
);
}
Search results may load additional results dynamically. A test can search for a keyword and continue scrolling until the required result is found.
public boolean findProduct(String product)
throws InterruptedException {
By productLocator = By.xpath(
"//*[contains(text(),'" + product + "')]"
);
JavascriptExecutor js =
(JavascriptExecutor) driver;
for (int i = 0; i < 15; i++) {
if (!driver.findElements(
productLocator
).isEmpty()) {
return true;
}
js.executeScript(
"window.scrollTo(0, document.body.scrollHeight);"
);
Thread.sleep(1000);
}
return false;
}
Long infinite-scroll pages can contain a large number of DOM elements. Loading too much content may increase browser memory usage and slow down automation.
Tests should therefore avoid unnecessarily loading the entire page when the business requirement only requires locating a particular item or validating a specific number of results.
Infinite-scroll tests can become flaky if the test assumes that content will load within a fixed amount of time. Network speed, server response time, JavaScript execution, animations, and application state can affect loading.
Stable tests should synchronize with observable application conditions.
Unstable Approach
Scroll
|
v
sleep(500)
|
v
Assume Content Loaded
Stable Approach
Scroll
|
v
Wait for Application Condition
|
v
Verify New Content
|
v
Continue
| Exception | Possible Cause | Typical Solution |
|---|---|---|
| StaleElementReferenceException | DOM changed after locating element | Locate the element again |
| NoSuchElementException | Element not loaded yet | Wait and retry |
| TimeoutException | Condition did not occur within timeout | Review condition and timeout |
| JavascriptException | Invalid or unsupported script execution | Validate JavaScript and context |
| ElementClickInterceptedException | Overlay or dynamic content blocks element | Wait, scroll, or handle overlay |
| WebDriverException | Browser/session-related issue | Check browser and driver/session configuration |
Start Test
|
v
Open Application
|
v
Locate Initial Content
|
v
Check Target / Content
|
+---- Found ----> Validate
|
v
Scroll
|
v
Wait for Dynamic Content
|
v
Check New Content
|
+---- No New Content ----> Stop / Fail
|
v
Check Maximum Attempts
|
+---- Limit Reached ----> Stop / Fail
|
v
Repeat
|
v
Target Found
|
v
Assertion
|
v
Test Complete
TestNG / PyTest
|
v
Test Class
|
v
Page Object
|
+----------------+
| |
v v
Element Methods Scroll Methods
| |
+--------+-------+
|
v
Selenium WebDriver
|
v
Browser
|
v
Dynamic Web Application
|
v
Newly Loaded Content
import java.time.Duration;
import java.util.List;
import org.openqa.selenium.By;
import org.openqa.selenium.JavascriptExecutor;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.Assert;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
public class InfiniteScrollTest {
WebDriver driver;
JavascriptExecutor js;
@BeforeMethod
public void setup() {
driver = new ChromeDriver();
driver.manage().window().maximize();
driver.manage().timeouts()
.implicitlyWait(Duration.ofSeconds(5));
js = (JavascriptExecutor) driver;
driver.get("https://example.com/products");
}
@Test
public void verifyInfiniteScroll() throws InterruptedException {
By products = By.cssSelector(".product-card");
int previousCount = 0;
int maxAttempts = 15;
for (int i = 0; i < maxAttempts; i++) {
int currentCount =
driver.findElements(products).size();
System.out.println(
"Products loaded: " + currentCount
);
if (currentCount == previousCount) {
break;
}
previousCount = currentCount;
js.executeScript(
"window.scrollTo(0, document.body.scrollHeight);"
);
Thread.sleep(1000);
}
List<WebElement> productList =
driver.findElements(products);
Assert.assertTrue(
productList.size() > 0,
"No products were loaded."
);
}
@AfterMethod
public void tearDown() {
if (driver != null) {
driver.quit();
}
}
}
Suppose an e-commerce application initially displays 20 products. When the user scrolls toward the bottom, another 20 products are loaded.
Initial Products = 20
|
v
Scroll Down
|
v
Products = 40
|
v
Scroll Down
|
v
Products = 60
|
v
Scroll Down
|
v
Products = 80
|
v
No More Products
|
v
Test Complete
A Selenium test can validate that products continue to load and that the application eventually reaches an end condition.
int productCount = driver.findElements(
By.cssSelector(".product-card")
).size();
System.out.println(
"Total products loaded: " + productCount
);
Assert.assertTrue(
productCount >= 20,
"Expected products were not loaded."
);
If the application provides a known final product, the automation can continue scrolling until the final item becomes available.
By lastProduct = By.xpath(
"//*[contains(text(),'Final Product')]"
);
boolean found = false;
for (int i = 0; i < 20; i++) {
if (!driver.findElements(lastProduct).isEmpty()) {
found = true;
break;
}
js.executeScript(
"window.scrollTo(0, document.body.scrollHeight);"
);
Thread.sleep(1000);
}
Assert.assertTrue(
found,
"Final product was not loaded."
);
The following pattern is useful when the application loads content based on reaching the document bottom.
long lastHeight = (Long) js.executeScript(
"return document.body.scrollHeight"
);
while (true) {
js.executeScript(
"window.scrollTo(0, document.body.scrollHeight);"
);
Thread.sleep(1500);
long newHeight = (Long) js.executeScript(
"return document.body.scrollHeight"
);
if (newHeight == lastHeight) {
break;
}
lastHeight = newHeight;
}
An end marker is often more reliable than simply comparing page heights when the application explicitly communicates that no more content is available.
By endMarker = By.cssSelector(".no-more-results");
while (driver.findElements(endMarker).isEmpty()) {
js.executeScript(
"window.scrollTo(0, document.body.scrollHeight);"
);
Thread.sleep(1000);
}
System.out.println(
"Reached the end of the content."
);
When the objective is to find one particular element, there is no need to load the entire page.
By target = By.xpath(
"//*[contains(text(),'Laptop Pro')]"
);
int maxAttempts = 15;
boolean found = false;
for (int i = 0; i < maxAttempts; i++) {
if (!driver.findElements(target).isEmpty()) {
found = true;
break;
}
js.executeScript(
"window.scrollTo(0, document.body.scrollHeight);"
);
Thread.sleep(1000);
}
Assert.assertTrue(
found,
"Laptop Pro was not found."
);
Infinite-scroll tests should provide useful reporting information. Logs can include the number of scroll attempts, number of loaded elements, target status, and final test result.
System.out.println(
"Scroll attempt: " + attempt
);
System.out.println(
"Elements loaded: " + elementCount
);
System.out.println(
"Target found: " + found
);
Sensitive information such as passwords, authentication tokens, and private user data should not be written into reports or console logs.
Infinite-scroll tests can be executed in CI/CD environments just like other Selenium tests. However, network conditions and browser resources can differ between local and CI environments, so synchronization should be designed to tolerate reasonable variations.
Developer Commit
|
v
CI/CD Pipeline
|
v
Build
|
v
Selenium Test
|
v
Open Application
|
v
Scroll
|
v
Wait for Content
|
v
Validate
|
v
Generate Report
|
v
Pipeline Result
Infinite scrolling should be tested across the browsers supported by the application because browser rendering, JavaScript execution, layout, and timing behavior can differ.
| Browser | Typical Validation |
|---|---|
| Chrome | Verify scroll and dynamic content loading |
| Firefox | Verify scroll behavior and element visibility |
| Edge | Verify dynamic content and interaction |
| Safari | Verify supported scrolling and lazy loading behavior |
Mobile applications and responsive websites may use different scrolling containers and loading mechanisms. When testing responsive web applications, verify that infinite scrolling behaves correctly across relevant viewport sizes.
Desktop View
|
v
Full Page Scroll
|
v
Dynamic Content
Mobile View
|
v
Responsive Container
|
v
Touch / Scroll Behavior
|
v
Dynamic Content
Infinite scrolling is a UI technique where additional content is dynamically loaded as the user scrolls toward the bottom of a page or container.
Selenium can handle infinite scrolling using JavaScript execution, Actions-based scrolling, element-based scrolling, container scrolling, waits, and application-specific loading conditions.
JavascriptExecutor is a Selenium interface that allows Java code to execute JavaScript in the current browser context.
js.executeScript(
"window.scrollTo(0, document.body.scrollHeight);"
);
You can compare document height, element count, loading indicators, end markers, or another application-specific condition.
Without a stopping condition, an automation loop can continue indefinitely if the page never reports that loading has finished.
It represents the scrollable height of the document body and can be used to determine whether the page has grown after additional content loads.
Window scrolling moves the main page viewport, while container scrolling moves a specific scrollable element inside the page.
Thread.sleep() always waits for a fixed duration and does not know whether the application has already loaded the content or needs additional time.
Explicit waits allow the test to wait for meaningful conditions such as new elements appearing or loading indicators disappearing.
It can occur when a previously located WebElement is no longer attached to the current DOM because the page changed dynamically.
Re-locate the element after the DOM update rather than relying on an old WebElement reference.
Check for the target element after each scroll and break the loop as soon as the target becomes available.
Use a maximum iteration count, timeout, document-height comparison, element-count comparison, or end-of-content marker.
Yes. JavaScript can modify the scrollTop property of a scrollable container, or Selenium Actions can be used for suitable scrolling scenarios.
Yes. Scrolling and page-specific element operations can be encapsulated in Page Object classes.
Yes. Data Providers can supply different search keywords, products, categories, or target values to the same infinite-scroll test.
Dynamic content depends on timing, network conditions, JavaScript execution, rendering, and application state. Poor synchronization can therefore produce inconsistent results.
No. If the test only needs to find a particular item, it is usually more efficient to stop once that item is found.
Use reliable locators, condition-based synchronization, safe stopping conditions, reusable scrolling utilities, appropriate assertions, and Page Object Model architecture.
| Concept | Purpose |
|---|---|
| Infinite Scrolling | Dynamically loads more content while scrolling |
| WebDriver | Controls the browser |
| JavascriptExecutor | Executes JavaScript in the browser |
| window.scrollTo() | Scrolls to a specific document position |
| window.scrollBy() | Scrolls by a specified amount |
| scrollHeight | Helps determine total scrollable height |
| Actions | Provides user-like scrolling operations |
| Explicit Wait | Waits for a specific condition |
| Element Count | Can indicate that additional content was loaded |
| Loading Spinner | Can indicate content loading status |
| End Marker | Indicates that no more content is available |
| Maximum Attempts | Prevents endless loops |
| POM | Separates page interaction logic from test logic |
Infinite scrolling is a common web application behavior in which additional content is dynamically loaded as the user reaches the bottom or another trigger point. Selenium automation must account for this dynamic behavior because all content may not be available when the initial page loads.
The most common Selenium techniques for infinite scrolling include JavaScript execution with JavascriptExecutor, Selenium Actions scrolling, element-based scrolling, container scrolling, and condition-based synchronization. Selenium's JavaScript executor is specifically designed to execute JavaScript in the current browsing context, while the Actions API provides scrolling operations such as scrolling to elements and by specified amounts. :contentReference[oaicite:4]{index=4}
A reliable infinite-scroll test should have a clear stopping condition, use appropriate synchronization, verify that new content has actually loaded, handle dynamic DOM changes, and avoid unnecessary scrolling when the required target has already been found.
For scalable Selenium frameworks, infinite-scrolling logic can be placed in reusable utility classes or Page Objects and combined with TestNG, Data Providers, assertions, reporting, Maven, and CI/CD execution.
Learn more about Selenium WebDriver and automation testing:
Final Takeaway: Infinite scrolling automation requires more than simply moving the browser scrollbar. A reliable Selenium implementation should understand how the application loads content, scroll using an appropriate mechanism, wait for dynamic updates, detect when additional content is no longer available, validate the loaded elements, and stop safely. Combining these techniques with Page Object Model and reusable utility methods makes infinite-scroll tests easier to maintain and scale.
