Implicit, Explicit, & Fluent Wait in Selenium WebDriver



In this tutorial, we will see different type of waits we use in Selenium. We will discuss about “Implicit”, “Explicit” and “Fluent” Wait.

Why do we need wait?

Nowadays web applications are developed using Ajax and Javascript, so when we try to identify a web  element on web page, there are the chances that the loading of that element will take some time or network connectivity is very poor result in “NoSuchElementException” exception. These issues can be resolved with the help of wait in Selenium.

Implicit Wait

The implicit wait will tell to the web driver to wait for certain amount of time before it throws a “NoSuchElementException“. The default setting is 0. Once we set the time, web driver will wait for that time before throwing an exception.

Implicit waits are used to provide a default waiting time (say 30 seconds) between each consecutive test step/command across the entire test script.We need to import java.util.concurrent.TimeUnit to use ImplicitWait.

driver.manage().timeouts().implicitlyWait(TimeOut, TimeUnit.SECONDS);

Implicit wait will accept 2 parameters, the first parameter will accept the time as an integer value and the second parameter will accept the time measurement in terms of SECONDS, MINUTES, MILISECOND, MICROSECONDS, NANOSECONDS, DAYS, HOURS, etc.

Let me show how to use implicit wait in our program

import java.util.concurrent.TimeUnit;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.firefox.FirefoxDriver;
public class ImplicitWait_Example {
      public static void main(String[] args) {
      WebDriver driver = new FirefoxDriver();
      //Implicit Wait
      driver.manage().timeouts().implicitlyWait(30, TimeUnit.SECONDS);

In the above example, we have waited for 30 sec, before redirecting the web page to the URL explicitly mentioned in the code.

Explicit Wait

An explicit wait is code you define to wait for a certain condition to occur before proceeding further in the code. The worst case of this is Thread.sleep(), which sets the condition to an exact time period to wait. There are convenience methods available to help write code that will only wait as long as required. 

WebDriverWait in combination with ExpectedCondition is one way to do this.

The explicit wait will tell the web driver to wait for certain conditions like visibilityOfElementLocated and maximum amount of time before throwing NoSuchElementException exception.

WebDriverWait wait = new WebDriverWait(WebDriverRefrence,TimeOut);

Let me explain this with an example

import java.util.concurrent.TimeUnit;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
public class ExplicitWaitExample {
            public static void main(String[] args) {
                        // Create a new instance of the Firefox driver
                        WebDriver driver = new ChromeDriver();
                        driver.manage().timeouts().implicitlyWait(30, TimeUnit.SECONDS);
                        // Click on READ MORE link. New Page is opened
                        driver.findElement(By.linkText("READ MORE")).click();
                        // Explicit Wait
                        WebDriverWait wait = new WebDriverWait(driver, 60);
                        String Count = driver.findElement("Stats1_totalCount")).getText();
                        System.out.println("Count is :" + Count);

In the above example, we have used Explicit Wait. We are waiting for the web element – Stats1_totalCount for 60 seconds before performing the next operation.

The following are the Expected Conditions that can used in Explicit Wait

  1. alertIsPresent()
  2. elementSelectionStateToBe()
  3. elementToBeClickable()
  4. elementToBeSelected()
  5. frameToBeAvaliableAndSwitchToIt()
  6. invisibilityOfTheElementLocated()
  7. invisibilityOfElementWithText()
  8. presenceOfAllElementsLocatedBy()
  9. presenceOfElementLocated()
  10. textToBePresentInElement()
  11. textToBePresentInElementLocated()
  12. textToBePresentInElementValue()
  13. titleIs()
  14. titleContains()
  15. visibilityOf()
  16. visibilityOfAllElements()
  17. visibilityOfAllElementsLocatedBy()
  18. visibilityOfElementLocated()

Note:-  Do not mix implicit and explicit waits! Doing so can cause unpredictable wait times. For example, setting an implicit wait of 20 seconds and an explicit wait of 35 seconds could cause a timeout to occur after 25 seconds.

Fluent Wait

The Fluent wait will tell the web driver to wait for certain conditions like visibilityOfElementLocated as well as the frequency with which we want to check before throwing NoSuchElementException exception.

To know more about Fluent Wait, please click here

3 thoughts on “Implicit, Explicit, & Fluent Wait in Selenium WebDriver

  1. Thanks Abhinav. Thread.sleep causes the current thread to suspend execution for a specified period. Thread is a class in JAVA and sleep() is the static method inside Thread class.Syntax – Thread.sleep(2000); where 2000 is the ms.But the disadvantage is that suppose we have mentioned wait for 5 sec whereas the element become visible in 2 ms only, so we have waited unnecessarily for 3 more ms. This will increase the execution time.


Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s