JustAcademy Selenium Training: JustAcademy Selenium Training Course
JustAcademy Demo Registration: Register for Selenium Course Demo
Explicit Wait in Selenium is a synchronization mechanism that allows WebDriver to wait for a specific condition to become true before continuing the test execution. Unlike Implicit Wait, which provides a general timeout for element searches, Explicit Wait is condition-specific and is especially useful for dynamic web applications where elements may appear, become visible, become enabled, become clickable, or change state after some time.
Explicit Wait is an important part of Selenium synchronization and dynamic-element handling. JustAcademy's Selenium curriculum includes Explicit Wait along with Implicit Wait, Fluent Wait, page load synchronization, dynamic element handling, and stable test execution strategies.
For structured Selenium learning covering WebDriver, WebElements, locators, waits, synchronization, dynamic elements, TestNG, Page Object Model, automation frameworks, and practical projects, visit Selenium Training Course.
For a practical course demonstration, visit Selenium Course Demo.
Explicit Wait is a Selenium synchronization technique used to wait for a particular condition before continuing execution. It allows the tester to define both the maximum waiting time and the condition that Selenium should monitor.
For example, a test may need to wait until a login button becomes clickable, a message becomes visible, a loader disappears, an alert appears, or a particular text is displayed.
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
Modern web applications are often dynamic. Elements may not be immediately ready when Selenium reaches the corresponding test step.
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
Here, driver is the WebDriver instance and Duration.ofSeconds(10) specifies the maximum time that the explicit wait can wait for the condition.
WebDriverWait is a Selenium Java wait utility used to wait until a specified condition is satisfied or the timeout is reached.
| Component | Meaning |
|---|---|
| WebDriverWait | Wait utility used for condition-based synchronization. |
| driver | The WebDriver instance controlling the browser. |
| Duration | Defines the maximum waiting period. |
| until() | Waits until the supplied condition is satisfied. |
The until() method is used to wait for a condition.
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement element = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("message")
)
);
Selenium repeatedly evaluates the condition until it succeeds or the configured timeout is reached.
Test Starts
↓
Create WebDriver
↓
Create WebDriverWait
↓
Define Condition
↓
Selenium Checks Condition
↓
Condition Satisfied?
↙ ↘
Yes No
↓ ↓
Continue Keep Polling
↓
Timeout Reached?
↙ ↘
No Yes
↓ ↓
Check Again TimeoutException
The main advantage of Explicit Wait is that it waits for a meaningful condition rather than simply delaying execution for a fixed amount of time.
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
wait.until(
ExpectedConditions.elementToBeClickable(
By.id("submit")
)
);
The test can continue as soon as the required condition is satisfied instead of always waiting for the entire ten seconds.
| Feature | Explicit Wait | Thread.sleep() |
|---|---|---|
| Type | Condition-based synchronization | Fixed delay |
| Condition | Yes | No |
| Efficiency | Can continue when condition is satisfied | Always waits the specified duration |
| Dynamic Applications | Suitable | Less suitable |
| Maintainability | Higher | Lower when used repeatedly |
| Feature | Implicit Wait | Explicit Wait |
|---|---|---|
| Scope | General element searches | Specific condition |
| Condition-Specific | No | Yes |
| Visibility | No direct condition | Supported |
| Clickability | No direct condition | Supported |
| Text | No direct condition | Supported |
| Alert | No direct condition | Supported |
| Frame | No direct condition | Supported |
| Custom Condition | Not intended for this | Supported |
Dynamic elements may appear only after JavaScript execution, API responses, AJAX calls, or other asynchronous operations.
Page Loaded
↓
JavaScript Executes
↓
API Request
↓
Response Received
↓
DOM Updated
↓
Element Becomes Visible
↓
Explicit Wait Detects Condition
↓
Test Continues
presenceOfElementLocated() waits until an element is present in the DOM.
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement username = wait.until(
ExpectedConditions.presenceOfElementLocated(
By.id("username")
)
);
Presence means the element has been located in the DOM. It does not necessarily mean that the element is visible or ready for interaction.
visibilityOfElementLocated() waits until the element is present and visible.
WebElement message = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("message")
)
);
This is useful when the test needs to interact with or validate a visible element.
If a WebElement has already been located, visibilityOf() can be used.
WebElement message =
driver.findElement(By.id("message"));
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
wait.until(
ExpectedConditions.visibilityOf(message)
);
elementToBeClickable() is commonly used when the test needs an element that is visible and enabled for interaction.
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement button = wait.until(
ExpectedConditions.elementToBeClickable(
By.id("submit")
)
);
button.click();
elementToBeSelected() can be used when the test needs to wait until an element becomes selected.
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
wait.until(
ExpectedConditions.elementToBeSelected(
By.id("terms")
)
);
elementSelectionStateToBe() can be used when the expected selected state needs to be explicitly defined.
wait.until(
ExpectedConditions.elementSelectionStateToBe(
By.id("terms"),
true
)
);
textToBePresentInElementLocated() waits until expected text is present inside a located element.
wait.until(
ExpectedConditions.textToBePresentInElementLocated(
By.id("status"),
"Completed"
)
);
When a WebElement is already available, Selenium provides conditions for checking expected text in that element.
WebElement status =
driver.findElement(By.id("status"));
wait.until(
ExpectedConditions.textToBePresentInElement(
status,
"Completed"
)
);
Dynamic applications may update attributes such as class, value, aria attributes, or custom attributes.
wait.until(
ExpectedConditions.attributeToBe(
By.id("status"),
"class",
"completed"
)
);
When only part of an attribute value needs to be matched, an attribute-based condition can be useful.
wait.until(
ExpectedConditions.attributeContains(
By.id("status"),
"class",
"active"
)
);
invisibilityOfElementLocated() is useful when a loader, spinner, overlay, or temporary element must disappear before the next operation.
wait.until(
ExpectedConditions.invisibilityOfElementLocated(
By.id("loader")
)
);
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(15)
);
wait.until(
ExpectedConditions.invisibilityOfElementLocated(
By.cssSelector(".loading-spinner")
)
);
This is often more meaningful than using a fixed sleep because the test can continue as soon as the loading indicator disappears.
When an alert is expected to appear asynchronously, alertIsPresent() can be used.
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
Alert alert = wait.until(
ExpectedConditions.alertIsPresent()
);
alert.accept();
When an iframe may not immediately be available, an explicit wait can wait until the frame is available and switch to it.
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
wait.until(
ExpectedConditions.frameToBeAvailableAndSwitchToIt(
By.id("paymentFrame")
)
);
When a user action opens a new tab or window, a custom wait can be used to wait until the expected number of window handles exists.
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
wait.until(
d -> d.getWindowHandles().size() > 1
);
Explicit Wait can also use a lambda expression when the required condition is not directly represented by a built-in ExpectedConditions method.
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
wait.until(
d -> d.findElement(By.id("status"))
.getText()
.equals("Completed")
);
Custom conditions are useful when an application has a specific state that cannot be handled directly by a standard expected condition.
wait.until(
driver -> {
String status =
driver.findElement(By.id("status"))
.getText();
return status.equals("Success");
}
);
A button may initially be disabled and become enabled after the user completes required fields.
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement submit = wait.until(
driver -> {
WebElement button =
driver.findElement(By.id("submit"));
return button.isEnabled() ? button : null;
}
);
submit.click();
driver.findElement(By.id("username"))
.sendKeys("admin");
driver.findElement(By.id("password"))
.sendKeys("password");
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement loginButton = wait.until(
ExpectedConditions.elementToBeClickable(
By.id("login")
)
);
loginButton.click();
driver.findElement(By.id("search"))
.sendKeys("Selenium");
driver.findElement(By.id("searchButton"))
.click();
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement result = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.cssSelector(".search-result")
)
);
System.out.println(result.getText());
AJAX can update only part of a web page. The browser may remain on the same page while the required content is being loaded.
User Action
↓
AJAX Request
↓
Server Processing
↓
Response
↓
DOM Update
↓
Explicit Wait
↓
Condition Satisfied
↓
Test Continues
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
List<WebElement> rows = wait.until(
ExpectedConditions.visibilityOfAllElementsLocatedBy(
By.cssSelector("table tbody tr")
)
);
for(WebElement row : rows){
System.out.println(row.getText());
}
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
List<WebElement> products = wait.until(
ExpectedConditions.visibilityOfAllElementsLocatedBy(
By.cssSelector(".product-card")
)
);
for(WebElement product : products){
System.out.println(product.getText());
}
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement login = wait.until(
ExpectedConditions.elementToBeClickable(
By.xpath("//button[@id='login']")
)
);
login.click();
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement username = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.cssSelector("#username")
)
);
username.sendKeys("admin");
WebElement username = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("username")
)
);
username.sendKeys("admin");
WebElement username = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.name("username")
)
);
username.sendKeys("admin");
WebElement button = wait.until(
ExpectedConditions.elementToBeClickable(
By.className("login-button")
)
);
button.click();
| Condition | Meaning |
|---|---|
| presenceOfElementLocated() | Element exists in the DOM. |
| visibilityOfElementLocated() | Element is present and visible. |
| elementToBeClickable() | Element is visible and enabled for interaction. |
Presence is appropriate when the test only needs the element to exist in the DOM.
WebElement element = wait.until(
ExpectedConditions.presenceOfElementLocated(
By.id("data")
)
);
Presence does not guarantee that the element is visible.
Visibility is appropriate when the element needs to be displayed before the test continues.
WebElement element = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("data")
)
);
Clickability is useful when a test needs an element that is visible and enabled before attempting a click.
WebElement element = wait.until(
ExpectedConditions.elementToBeClickable(
By.id("submit")
)
);
element.click();
Explicit Wait can be combined with visibility conditions when the test requires a dynamically displayed element.
WebElement message = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("message")
)
);
System.out.println(
message.isDisplayed()
);
When a control becomes enabled dynamically, a custom condition or clickability condition can be used.
WebElement button = wait.until(
ExpectedConditions.elementToBeClickable(
By.id("submit")
)
);
System.out.println(
button.isEnabled()
);
When a checkbox or radio button becomes selected after a user action or application update, an explicit selection condition can be used.
wait.until(
ExpectedConditions.elementToBeSelected(
By.id("terms")
)
);
WebElement checkbox = wait.until(
ExpectedConditions.elementToBeClickable(
By.id("terms")
)
);
if(!checkbox.isSelected()){
checkbox.click();
}
wait.until(
ExpectedConditions.elementToBeSelected(
By.id("terms")
)
);
WebElement male = wait.until(
ExpectedConditions.elementToBeClickable(
By.id("male")
)
);
male.click();
wait.until(
ExpectedConditions.elementToBeSelected(
By.id("male")
)
);
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement toast = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.cssSelector(".toast")
)
);
System.out.println(toast.getText());
driver.findElement(By.id("login"))
.click();
WebElement error = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("errorMessage")
)
);
System.out.println(error.getText());
WebElement success = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.cssSelector(".success-message")
)
);
String message = success.getText();
System.out.println(message);
WebElement modal = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("confirmationModal")
)
);
System.out.println(
modal.getText()
);
wait.until(
ExpectedConditions.invisibilityOfElementLocated(
By.id("confirmationModal")
)
);
WebElement dropdown = wait.until(
ExpectedConditions.elementToBeClickable(
By.id("country")
)
);
dropdown.click();
driver.findElement(By.id("search"))
.sendKeys("Selenium");
List<WebElement> suggestions = wait.until(
ExpectedConditions.visibilityOfAllElementsLocatedBy(
By.cssSelector(".suggestion")
)
);
for(WebElement suggestion : suggestions){
System.out.println(suggestion.getText());
}
driver.findElement(By.id("search"))
.sendKeys("Laptop");
driver.findElement(By.id("searchButton"))
.click();
WebElement product = wait.until(
ExpectedConditions.elementToBeClickable(
By.cssSelector(".product-card")
)
);
product.click();
WebElement addToCart = wait.until(
ExpectedConditions.elementToBeClickable(
By.id("addToCart")
)
);
addToCart.click();
WebElement checkout = wait.until(
ExpectedConditions.elementToBeClickable(
By.id("checkout")
)
);
checkout.click();
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement username = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("username")
)
);
WebElement password = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("password")
)
);
username.sendKeys("admin");
password.sendKeys("password");
WebElement login = wait.until(
ExpectedConditions.elementToBeClickable(
By.id("login")
)
);
login.click();
driver.get("https://example.com/login");
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement username = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("username")
)
);
username.sendKeys("admin");
driver.findElement(By.id("login"))
.click();
WebElement dashboard = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("dashboard")
)
);
System.out.println(
dashboard.getText()
);
Dynamic applications may replace elements in the DOM. A previously stored WebElement can become stale after a DOM refresh or re-render.
WebElement element =
driver.findElement(By.id("dynamic"));
driver.navigate().refresh();
element.click();
When the DOM changes, locating the element again inside the wait condition can be safer than relying on an old reference.
WebElement element = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("dynamic")
)
);
element.click();
Using a locator-based condition allows Selenium to perform the lookup as part of the wait operation.
If the required condition does not become true within the configured timeout, Selenium can throw TimeoutException.
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("element")
)
);
try{
WebElement element = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("element")
)
);
System.out.println(element.getText());
}
catch(TimeoutException e){
System.out.println(
"Element did not become visible in time."
);
}
When a locator-based expected condition is used, the wait repeatedly performs the required lookup. If the condition cannot be satisfied before timeout, the wait ultimately fails.
WebElement element = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("dynamicElement")
)
);
driver.findElement(By.id("search"))
.sendKeys("Selenium");
driver.findElement(By.id("searchButton"))
.click();
wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.cssSelector(".search-results")
)
);
wait.until(
ExpectedConditions.invisibilityOfElementLocated(
By.id("loader")
)
);
WebElement content = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("content")
)
);
System.out.println(content.getText());
WebDriverWait is built on Selenium's fluent waiting mechanism. For advanced synchronization, a FluentWait can provide control over timeout, polling interval, and ignored exceptions.
Wait<WebDriver> wait =
new FluentWait<WebDriver>(driver)
.withTimeout(Duration.ofSeconds(20))
.pollingEvery(Duration.ofSeconds(2))
.ignoring(NoSuchElementException.class);
WebElement element = wait.until(
d -> d.findElement(By.id("dynamic"))
);
Explicit Wait does not normally execute one single check and immediately fail. It repeatedly evaluates the condition until it succeeds or the timeout is reached.
Start
↓
Check Condition
↓
Condition True?
↙ ↘
Yes No
↓ ↓
Continue Poll Again
↓
Timeout Reached?
For more advanced waiting requirements, polling frequency can be customized through FluentWait.
Wait<WebDriver> wait =
new FluentWait<WebDriver>(driver)
.withTimeout(Duration.ofSeconds(20))
.pollingEvery(Duration.ofSeconds(2));
FluentWait can be configured to ignore selected exceptions while polling for a condition.
Wait<WebDriver> wait =
new FluentWait<WebDriver>(driver)
.withTimeout(Duration.ofSeconds(20))
.pollingEvery(Duration.ofSeconds(2))
.ignoring(NoSuchElementException.class);
In a Page Object Model framework, explicit waits can be encapsulated inside page classes or reusable wait utilities.
public class LoginPage {
private WebDriver driver;
private WebDriverWait wait;
private By username =
By.id("username");
private By password =
By.id("password");
private By loginButton =
By.id("login");
public LoginPage(WebDriver driver){
this.driver = driver;
this.wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
}
public void login(
String user,
String pass
){
wait.until(
ExpectedConditions.visibilityOfElementLocated(
username
)
).sendKeys(user);
wait.until(
ExpectedConditions.visibilityOfElementLocated(
password
)
).sendKeys(pass);
wait.until(
ExpectedConditions.elementToBeClickable(
loginButton
)
).click();
}
}
A reusable wait utility can reduce duplicate synchronization code in larger frameworks.
public class WaitUtils {
private WebDriver driver;
private WebDriverWait wait;
public WaitUtils(WebDriver driver){
this.driver = driver;
this.wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
}
public WebElement waitForVisible(By locator){
return wait.until(
ExpectedConditions.visibilityOfElementLocated(
locator
)
);
}
public WebElement waitForClickable(By locator){
return wait.until(
ExpectedConditions.elementToBeClickable(
locator
)
);
}
}
@BeforeMethod
public void setup(){
driver = new ChromeDriver();
driver.manage().window().maximize();
}
@Test
public void loginTest(){
driver.get("https://example.com/login");
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("username")
)
).sendKeys("admin");
wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("password")
)
).sendKeys("password");
wait.until(
ExpectedConditions.elementToBeClickable(
By.id("login")
)
).click();
}
WebElement dashboard = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("dashboard")
)
);
Assert.assertTrue(
dashboard.isDisplayed()
);
Explicit Wait can be reused while executing the same workflow with multiple test data sets.
for(String username : usernames){
WebElement input = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("username")
)
);
input.clear();
input.sendKeys(username);
}
Explicit Wait works with Selenium WebDriver regardless of whether the test is executed against Chrome, Firefox, Edge, or another supported browser.
WebDriver driver = new ChromeDriver();
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement element = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("username")
)
);
CI/CD environments can have different execution characteristics from local systems. Condition-based waits can help tests synchronize with actual application state instead of relying on fixed delays.
Local Machine
↓
Application Response
↓
Condition Check
↓
Test Continues
CI Server
↓
Application Response
↓
Condition Check
↓
Test Continues
The timeout should be realistic for the application and execution environment.
| Timeout | Possible Effect |
|---|---|
| Very Short | May cause failures when the application is temporarily slow. |
| Reasonable | Allows normal application response variation. |
| Very Long | Can delay failure detection and increase test execution time. |
Waiting cannot correct a locator that does not identify the required element.
wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("incorrect-id")
)
);
If the actual element uses a different ID, increasing the timeout will not make the locator correct.
If an application has a genuine defect and the expected element or state never occurs, an explicit wait will eventually fail with a timeout. A wait should synchronize with expected application behavior, not hide application defects.
elementToBeClickable() checks whether an element is visible and enabled, but a click can still fail because of overlays, DOM changes, interception, browser behavior, animations, or other application conditions.
WebElement button = wait.until(
ExpectedConditions.elementToBeClickable(
By.id("submit")
)
);
button.click();
A transparent or visible overlay can block interaction with an element. In such cases, waiting for the target element alone may not be enough.
wait.until(
ExpectedConditions.invisibilityOfElementLocated(
By.id("overlay")
)
);
wait.until(
ExpectedConditions.elementToBeClickable(
By.id("submit")
)
).click();
Animations can temporarily affect interaction. A framework may wait for a relevant state or for the animation-related element to disappear or reach the expected state.
wait.until(
ExpectedConditions.invisibilityOfElementLocated(
By.cssSelector(".animation-loader")
)
);
wait.until(
ExpectedConditions.frameToBeAvailableAndSwitchToIt(
By.cssSelector("iframe.payment")
)
);
driver.findElement(By.id("cardNumber"))
.sendKeys("123456789");
driver.findElement(By.id("delete"))
.click();
Alert alert = wait.until(
ExpectedConditions.alertIsPresent()
);
System.out.println(alert.getText());
alert.accept();
String originalWindow =
driver.getWindowHandle();
driver.findElement(By.id("open"))
.click();
wait.until(
d -> d.getWindowHandles().size() > 1
);
for(String window : driver.getWindowHandles()){
if(!window.equals(originalWindow)){
driver.switchTo().window(window);
break;
}
}
A custom condition can be used when navigation is expected to result in a particular URL.
wait.until(
ExpectedConditions.urlContains("dashboard")
);
Selenium provides conditions for waiting until the page title contains or matches expected text.
wait.until(
ExpectedConditions.titleContains("Dashboard")
);
wait.until(
ExpectedConditions.urlToBe(
"https://example.com/dashboard"
)
);
When a specific DOM state represents application readiness, a custom lambda can be used.
wait.until(
driver -> driver.findElement(
By.id("status")
).getAttribute("data-state")
.equals("ready")
);
wait.until(
driver -> {
WebElement status =
driver.findElement(By.id("status"));
return status.getText().equals("Ready");
}
);
driver.findElement(By.id("email"))
.sendKeys("[email protected]");
wait.until(
ExpectedConditions.attributeContains(
By.id("email"),
"class",
"valid"
)
);
driver.findElement(By.id("search"))
.sendKeys("Selenium");
List<WebElement> suggestions = wait.until(
ExpectedConditions.visibilityOfAllElementsLocatedBy(
By.cssSelector(".suggestion-item")
)
);
suggestions.get(0).click();
WebElement notification = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.cssSelector(".notification")
)
);
Assert.assertTrue(
notification.getText()
.contains("Success")
);
When a file upload causes a status element to appear, Selenium can wait for that status instead of relying on a fixed delay.
driver.findElement(By.id("file"))
.sendKeys("/path/to/file.pdf");
WebElement status = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("uploadStatus")
)
);
System.out.println(status.getText());
For downloads, the synchronization requirement is often outside the DOM. The test may need to verify the filesystem or application download status rather than simply waiting for a web element.
driver.findElement(By.id("download"))
.click();
wait.until(
driver -> {
return new File(
"/downloads/report.pdf"
).exists();
}
);
A good synchronization strategy should be combined with stable locators. Explicit Wait cannot compensate for locators that frequently change or identify the wrong element.
Application Action
↓
Application Processing
↓
Identify Required State
↓
Choose Correct Expected Condition
↓
Create Explicit Wait
↓
Wait Until Condition
↓
Condition Satisfied
↓
Perform Next Action
↓
Validate Result
| Requirement | Recommended Condition |
|---|---|
| Element exists in DOM | presenceOfElementLocated() |
| Element is visible | visibilityOfElementLocated() |
| Element can be clicked | elementToBeClickable() |
| Element is selected | elementToBeSelected() |
| Text appears | textToBePresentInElementLocated() |
| Loader disappears | invisibilityOfElementLocated() |
| Alert appears | alertIsPresent() |
| Frame becomes available | frameToBeAvailableAndSwitchToIt() |
| URL changes | urlContains() or urlToBe() |
| Title changes | titleContains() or titleIs() |
| Custom application state | Lambda or custom condition |
import java.time.Duration;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
public class ExplicitWaitLoginTest {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
driver.manage().window().maximize();
driver.get("https://example.com/login");
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement username = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("username")
)
);
username.sendKeys("admin");
WebElement password = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("password")
)
);
password.sendKeys("password");
WebElement loginButton = wait.until(
ExpectedConditions.elementToBeClickable(
By.id("login")
)
);
loginButton.click();
WebElement dashboard = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("dashboard")
)
);
System.out.println(
"Dashboard: " + dashboard.getText()
);
driver.quit();
}
}
WebDriver driver = new ChromeDriver();
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(15)
);
driver.get("https://example.com");
WebElement search = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("search")
)
);
search.sendKeys("Laptop");
wait.until(
ExpectedConditions.elementToBeClickable(
By.id("searchButton")
)
).click();
WebElement product = wait.until(
ExpectedConditions.elementToBeClickable(
By.cssSelector(".product-card")
)
);
product.click();
wait.until(
ExpectedConditions.elementToBeClickable(
By.id("addToCart")
)
).click();
wait.until(
ExpectedConditions.elementToBeClickable(
By.id("checkout")
)
).click();
driver.quit();
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("name")
)
).sendKeys("John");
wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("email")
)
).sendKeys("[email protected]");
wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("password")
)
).sendKeys("Password123");
wait.until(
ExpectedConditions.elementToBeClickable(
By.id("register")
)
).click();
WebElement success = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("success")
)
);
System.out.println(success.getText());
driver.get("https://example.com/dashboard");
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(15)
);
wait.until(
ExpectedConditions.invisibilityOfElementLocated(
By.id("loader")
)
);
WebElement dashboard = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("dashboard")
)
);
WebElement reports = wait.until(
ExpectedConditions.elementToBeClickable(
By.id("reports")
)
);
reports.click();
Answer: Explicit Wait is a Selenium synchronization mechanism that waits for a specific condition to become true before allowing test execution to continue or until the configured timeout is reached.
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
Answer: The until() method waits until the supplied condition is satisfied or the configured timeout is reached.
Answer: ExpectedConditions is a Selenium utility that provides commonly used conditions for Explicit Wait, such as visibility, presence, clickability, text, alerts, frames, selection, URLs, titles, and other states.
Answer: Presence means the element exists in the DOM. Visibility means the element is present and displayed according to WebDriver's visibility rules.
Answer: elementToBeClickable() is an ExpectedCondition used to wait until an element is visible and enabled for interaction.
Answer: If the required condition does not become true within the configured timeout, Selenium generally throws a TimeoutException.
Answer: Yes. Explicit Wait is particularly useful for dynamic elements because it can wait for specific states such as presence, visibility, clickability, text, selection, or custom application conditions.
Answer: For normal synchronization requirements, condition-based Explicit Wait is generally more appropriate than fixed Thread.sleep() delays because it waits for the required state rather than an arbitrary amount of time.
Answer: Yes. Selenium provides alertIsPresent() for waiting until a JavaScript alert is available.
Alert alert = wait.until(
ExpectedConditions.alertIsPresent()
);
Answer: Yes. Selenium provides frameToBeAvailableAndSwitchToIt() for waiting until a frame is available and switching into it.
Answer: Yes. Conditions such as textToBePresentInElementLocated() can be used when test execution depends on dynamic text.
Answer: Yes. invisibilityOfElementLocated() can be used to wait until a loading indicator or other temporary element becomes invisible.
Answer: WebDriverWait provides a convenient condition-based waiting mechanism, while FluentWait provides more configurable control over timeout, polling interval, and ignored exceptions. WebDriverWait is built on Selenium's fluent waiting mechanism.
Answer: They can be configured together, but their interaction should be understood because mixing them without a clear strategy can make timeout behavior harder to reason about. A consistent synchronization strategy is generally easier to maintain.
Answer: No. Explicit Wait only waits for the condition associated with the locator. If the locator is incorrect, the expected condition will not become true.
Answer: No. elementToBeClickable() waits for visibility and enabled state, but actual interaction can still be affected by overlays, DOM changes, interception, animations, or other browser/application conditions.
| Concept | Details |
|---|---|
| Primary Class | WebDriverWait |
| Main Method | until() |
| Purpose | Condition-specific synchronization. |
| Common Condition | visibilityOfElementLocated() |
| Clickable Condition | elementToBeClickable() |
| Presence Condition | presenceOfElementLocated() |
| Text Condition | textToBePresentInElementLocated() |
| Alert Condition | alertIsPresent() |
| Frame Condition | frameToBeAvailableAndSwitchToIt() |
| Selection Condition | elementToBeSelected() |
| Invisible Condition | invisibilityOfElementLocated() |
| Failure | TimeoutException when condition is not satisfied within timeout. |
Explicit Wait is one of the most useful synchronization mechanisms in Selenium automation. It allows a test to wait for a specific condition before continuing execution. This makes it particularly useful for modern dynamic web applications where elements can appear, disappear, become visible, become enabled, change text, or update their state asynchronously.
The basic Selenium Java syntax is WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));. The until() method is then used with a suitable expected condition.
Common conditions include presenceOfElementLocated(), visibilityOfElementLocated(), elementToBeClickable(), textToBePresentInElementLocated(), invisibilityOfElementLocated(), alertIsPresent(), frameToBeAvailableAndSwitchToIt(), and elementToBeSelected().
Explicit Wait is different from Implicit Wait because it is condition-specific, while Implicit Wait provides a general timeout for applicable element searches. Explicit Wait is also different from Thread.sleep(), because it can stop waiting as soon as the required condition is satisfied rather than always pausing for a fixed duration.
A reliable Selenium framework should use meaningful conditions, stable locators, realistic timeout values, reusable wait utilities, and synchronization based on actual application state. Explicit Wait should be used to synchronize with expected application behavior rather than to hide incorrect locators or application defects.
For detailed Selenium automation training covering WebDriver, locators, waits, synchronization, dynamic elements, TestNG, Page Object Model, frameworks, and practical automation projects, visit Selenium Training Course.
To explore a practical Selenium course demonstration, visit Register for Selenium Course Demo.
