isDisplayed() is a Selenium WebDriver method used to determine whether a web element is currently displayed on a web page. It returns a boolean value: true when the element is displayed and false when the element is not displayed.
The method is commonly used to verify the visibility of buttons, text fields, labels, images, menus, links, messages, forms, popups, error messages, and other web elements during automated testing.
JustAcademy's Selenium Automation Testing course covers Selenium WebDriver, WebElements, locators, TestNG, automation frameworks, Page Object Model, dynamic elements, cross-browser testing, and real-time automation projects. You can learn more through the Selenium Training Course and register for a Selenium Course Demo.
isDisplayed() is a method of the Selenium WebElement interface. It checks whether a particular web element is displayed to the user according to WebDriver's visibility rules.
The method returns a boolean value.
boolean result = element.isDisplayed();If the element is displayed, the result is:
trueIf the element is not displayed, the result is:
falseIn web automation, locating an element does not always mean that the element is currently visible. Modern web applications frequently hide and display elements based on user actions, application state, permissions, validation, AJAX requests, menus, dialogs, and responsive layouts.
The basic syntax is:
element.isDisplayed();Usually, the result is stored in a boolean variable.
boolean displayed = element.isDisplayed();WebElement loginButton = driver.findElement(By.id("login"));
boolean displayed = loginButton.isDisplayed();
System.out.println("Login Button Displayed: " + displayed);
If the login button is visible, Selenium returns true.
The return type of isDisplayed() is boolean.
| Result | Meaning |
|---|---|
| true | The element is displayed. |
| false | The element is not displayed. |
WebElement button = driver.findElement(By.id("submit"));
if (button.isDisplayed()) {
System.out.println("Submit button is displayed");
}
WebElement errorMessage = driver.findElement(By.id("error"));
if (!errorMessage.isDisplayed()) {
System.out.println("Error message is not displayed");
}
WebElement element = driver.findElement(By.id("message"));
if (element.isDisplayed()) {
System.out.println("Element is visible");
} else {
System.out.println("Element is not visible");
}
WebElement logo = driver.findElement(By.id("logo"));
boolean isVisible = logo.isDisplayed();
System.out.println("Logo visible: " + isVisible);
TestNG assertions can be used to verify that an element is displayed.
WebElement loginButton = driver.findElement(By.id("login"));
Assert.assertTrue(loginButton.isDisplayed());
This test passes when the login button is displayed.
WebElement errorMessage = driver.findElement(By.id("error"));
Assert.assertFalse(errorMessage.isDisplayed());
isDisplayed() and isEnabled() check different properties of a web element.
| Method | Purpose | Return Type |
|---|---|---|
| isDisplayed() | Checks whether the element is displayed. | boolean |
| isEnabled() | Checks whether the element is enabled. | boolean |
An element can be displayed but disabled.
boolean visible = button.isDisplayed();
boolean enabled = button.isEnabled();
isSelected() is generally used for checkboxes, radio buttons, and options, while isDisplayed() checks visibility.
| Method | Checks |
|---|---|
| isDisplayed() | Visibility/displayed state |
| isSelected() | Selected state |
| isEnabled() | Enabled state |
isDisplayed() returns whether an element is displayed, while getText() retrieves the visible text associated with the element.
WebElement message = driver.findElement(By.id("message"));
boolean displayed = message.isDisplayed();
String text = message.getText();
System.out.println("Displayed: " + displayed);
System.out.println("Text: " + text);
isDisplayed() checks displayed state, whereas getAttribute() retrieves an attribute or property-related value from the element.
WebElement input = driver.findElement(By.id("username"));
boolean displayed = input.isDisplayed();
String value = input.getAttribute("value");
System.out.println("Displayed: " + displayed);
System.out.println("Value: " + value);
Before entering credentials, a test can verify that the login form is displayed.
WebElement username = driver.findElement(By.id("username"));
WebElement password = driver.findElement(By.id("password"));
WebElement loginButton = driver.findElement(By.id("login"));
Assert.assertTrue(username.isDisplayed());
Assert.assertTrue(password.isDisplayed());
Assert.assertTrue(loginButton.isDisplayed());
WebElement logo = driver.findElement(By.cssSelector(".logo"));
if (logo.isDisplayed()) {
System.out.println("Logo is displayed");
} else {
System.out.println("Logo is not displayed");
}
WebElement menu = driver.findElement(By.id("menu"));
Assert.assertTrue(menu.isDisplayed());
WebElement productImage = driver.findElement(
By.cssSelector(".product-image")
);
if (productImage.isDisplayed()) {
System.out.println("Product image is visible");
}
WebElement username = driver.findElement(By.id("username"));
if (username.isDisplayed()) {
username.sendKeys("testuser");
}
Checking visibility before interaction can make the test flow easier to understand, although for dynamic applications an appropriate explicit wait is usually better than an immediate visibility check.
WebElement submit = driver.findElement(By.id("submit"));
boolean visible = submit.isDisplayed();
System.out.println("Submit button visible: " + visible);
Error messages are often displayed only after invalid data is submitted.
WebElement error = driver.findElement(By.id("error"));
if (error.isDisplayed()) {
System.out.println("Validation error is displayed");
}
WebElement success = driver.findElement(By.id("success"));
Assert.assertTrue(success.isDisplayed());
WebElement popup = driver.findElement(By.id("popup"));
if (popup.isDisplayed()) {
System.out.println("Popup is displayed");
}
Some web applications contain elements in the DOM that are not currently displayed.
WebElement element = driver.findElement(By.id("hiddenElement"));
boolean visible = element.isDisplayed();
System.out.println("Visible: " + visible);
The element can exist in the DOM while its displayed state is false.
Finding an element and displaying an element are different concepts. findElement() attempts to locate an element in the DOM, while isDisplayed() checks whether the located element is displayed.
WebElement element = driver.findElement(By.id("message"));
boolean displayed = element.isDisplayed();
A successfully located element is not automatically guaranteed to be visible.
If the element cannot be found, findElement() can throw NoSuchElementException. In that situation, Selenium never reaches the isDisplayed() call.
WebElement element = driver.findElement(By.id("missingElement"));
boolean visible = element.isDisplayed();
For dynamic pages, explicit waits can be used when an element may appear later.
WebElement loginButton = driver.findElement(
By.xpath("//button[@id='login']")
);
boolean visible = loginButton.isDisplayed();
System.out.println("Visible: " + visible);
WebElement loginButton = driver.findElement(
By.cssSelector("#login")
);
Assert.assertTrue(loginButton.isDisplayed());
WebElement logo = driver.findElement(
By.className("logo")
);
System.out.println(logo.isDisplayed());
WebElement homeLink = driver.findElement(
By.linkText("Home")
);
if (homeLink.isDisplayed()) {
System.out.println("Home link is visible");
}
WebElement link = driver.findElement(
By.partialLinkText("Learn")
);
Assert.assertTrue(link.isDisplayed());
When multiple elements need to be checked, Selenium's findElements() method can be useful.
List<WebElement> buttons = driver.findElements(
By.cssSelector("button")
);
for (WebElement button : buttons) {
System.out.println(
"Button displayed: " + button.isDisplayed()
);
}
List<WebElement> buttons = driver.findElements(
By.cssSelector("button")
);
for (WebElement button : buttons) {
if (button.isDisplayed()) {
System.out.println("Visible button found");
}
}
List<WebElement> elements = driver.findElements(
By.cssSelector(".item")
);
int visibleCount = 0;
for (WebElement element : elements) {
if (element.isDisplayed()) {
visibleCount++;
}
}
System.out.println("Visible elements: " + visibleCount);
List<WebElement> elements = driver.findElements(
By.cssSelector(".notification")
);
boolean foundVisible = false;
for (WebElement element : elements) {
if (element.isDisplayed()) {
foundVisible = true;
break;
}
}
System.out.println("Visible notification found: " + foundVisible);
For dynamic applications, an immediate call to isDisplayed() may happen before the element becomes visible. Selenium's explicit wait can wait for a visibility condition.
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement message = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("message")
)
);
System.out.println("Message is visible");
visibilityOfElementLocated() is an ExpectedCondition that waits until an element is located and considered visible.
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement element = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("login")
)
);
If a WebElement has already been located, visibilityOf() can be used with an explicit wait.
WebElement message = driver.findElement(By.id("message"));
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
wait.until(ExpectedConditions.visibilityOf(message));
| Feature | isDisplayed() | visibilityOfElementLocated() |
|---|---|---|
| Type | WebElement method | ExpectedCondition |
| Purpose | Immediately checks displayed state | Waits for visibility |
| Return | boolean | WebElement |
| Synchronization | No | Yes, when used with WebDriverWait |
One of the most important concepts is that isDisplayed() is an immediate state check. It does not automatically wait for an element to become visible.
boolean visible = element.isDisplayed();If the application displays the element one second later, the immediate call does not wait for that future state.
Consider a page where a success message appears after clicking a Save button.
driver.findElement(By.id("save")).click();
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement message = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("success")
)
);
Assert.assertTrue(message.isDisplayed());
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")
)
);
WebElement loginButton = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("login")
)
);
Assert.assertTrue(username.isDisplayed());
Assert.assertTrue(password.isDisplayed());
Assert.assertTrue(loginButton.isDisplayed());
driver.findElement(By.id("menuButton")).click();
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement menu = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("menu")
)
);
Assert.assertTrue(menu.isDisplayed());
driver.findElement(By.id("openModal")).click();
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement modal = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("modal")
)
);
Assert.assertTrue(modal.isDisplayed());
Loading indicators are commonly displayed while AJAX or other asynchronous operations are running.
WebElement loader = driver.findElement(By.id("loader"));
if (loader.isDisplayed()) {
System.out.println("Loading is in progress");
}
When the requirement is to verify that a loading element is no longer displayed, an explicit wait can be used.
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
wait.until(
ExpectedConditions.invisibilityOfElementLocated(
By.id("loader")
)
);
System.out.println("Loader is no longer visible");
After waiting for invisibility, an element can be checked again if it is still represented in the DOM.
WebElement loader = driver.findElement(By.id("loader"));
boolean visible = loader.isDisplayed();
System.out.println("Loader visible: " + visible);
WebElement countryDropdown = driver.findElement(
By.id("country")
);
Assert.assertTrue(countryDropdown.isDisplayed());
WebElement terms = driver.findElement(By.id("terms"));
if (terms.isDisplayed()) {
System.out.println("Terms checkbox is visible");
}
WebElement male = driver.findElement(By.id("male"));
Assert.assertTrue(male.isDisplayed());
WebElement table = driver.findElement(By.id("usersTable"));
Assert.assertTrue(table.isDisplayed());
List<WebElement> rows = driver.findElements(
By.cssSelector("#usersTable tbody tr")
);
for (WebElement row : rows) {
if (row.isDisplayed()) {
System.out.println("Visible row: " + row.getText());
}
}
List<WebElement> products = driver.findElements(
By.cssSelector(".product-card")
);
for (WebElement product : products) {
if (product.isDisplayed()) {
System.out.println("Product card is visible");
}
}
WebElement addToCart = driver.findElement(
By.cssSelector(".add-to-cart")
);
if (addToCart.isDisplayed()) {
System.out.println("Add to Cart button is visible");
}
WebElement checkoutForm = driver.findElement(
By.id("checkoutForm")
);
Assert.assertTrue(checkoutForm.isDisplayed());
WebElement product = driver.findElement(
By.cssSelector(".product-card")
);
WebElement addToCart = product.findElement(
By.cssSelector(".add-to-cart")
);
if (product.isDisplayed() && addToCart.isDisplayed()) {
addToCart.click();
}
WebElement username = driver.findElement(By.id("username"));
WebElement password = driver.findElement(By.id("password"));
WebElement login = driver.findElement(By.id("login"));
if (username.isDisplayed() &&
password.isDisplayed() &&
login.isDisplayed()) {
username.sendKeys("testuser");
password.sendKeys("password");
login.click();
}
driver.findElement(By.id("login")).click();
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement error = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("loginError")
)
);
Assert.assertTrue(error.isDisplayed());
driver.findElement(By.id("submit")).click();
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement success = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("successMessage")
)
);
Assert.assertTrue(success.isDisplayed());
driver.findElement(By.id("help")).click();
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement tooltip = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("tooltip")
)
);
Assert.assertTrue(tooltip.isDisplayed());
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement notification = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.cssSelector(".notification")
)
);
System.out.println(notification.isDisplayed());
In the Page Object Model, visibility checks can be placed inside reusable page methods.
public class LoginPage {
private WebDriver driver;
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;
}
public boolean isUsernameDisplayed() {
return driver.findElement(username).isDisplayed();
}
public boolean isPasswordDisplayed() {
return driver.findElement(password).isDisplayed();
}
public boolean isLoginButtonDisplayed() {
return driver.findElement(loginButton).isDisplayed();
}
}
LoginPage loginPage = new LoginPage(driver);
Assert.assertTrue(loginPage.isUsernameDisplayed());
Assert.assertTrue(loginPage.isPasswordDisplayed());
Assert.assertTrue(loginPage.isLoginButtonDisplayed());
A generic helper method can be created for visibility checks.
public boolean isElementDisplayed(By locator) {
try {
return driver.findElement(locator).isDisplayed();
} catch (NoSuchElementException e) {
return false;
}
}
This approach can be useful when the test intentionally needs a boolean result instead of an exception when an element is absent.
public boolean waitForElementVisible(By locator) {
try {
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
wait.until(
ExpectedConditions.visibilityOfElementLocated(locator)
);
return true;
} catch (TimeoutException e) {
return false;
}
}
If an element may not exist at all, calling findElement() directly can throw an exception. A helper method can handle this situation.
try {
WebElement element = driver.findElement(By.id("message"));
if (element.isDisplayed()) {
System.out.println("Message is visible");
}
} catch (NoSuchElementException e) {
System.out.println("Message element does not exist");
}
Modern web applications can replace DOM elements during AJAX updates or framework re-rendering. A previously stored WebElement may then become stale.
try {
WebElement element = driver.findElement(By.id("message"));
System.out.println(element.isDisplayed());
} catch (StaleElementReferenceException e) {
System.out.println("Element became stale");
}
Frameworks such as React, Angular, and other client-side applications can dynamically create, remove, hide, show, or replace elements.
For these applications, visibility should generally be synchronized with explicit waits rather than relying only on immediate calls.
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement element = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("dynamicElement")
)
);
AJAX operations can update part of a web page without performing a complete page reload. An element may therefore become visible only after an asynchronous operation finishes.
driver.findElement(By.id("loadData")).click();
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement data = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("data")
)
);
Assert.assertTrue(data.isDisplayed());
Responsive applications can show or hide different elements depending on viewport size. Therefore, an element displayed on desktop may not be displayed in the same way on a smaller viewport.
driver.manage().window().setSize(
new Dimension(1280, 720)
);
WebElement desktopMenu = driver.findElement(
By.id("desktopMenu")
);
System.out.println(
"Desktop Menu: " + desktopMenu.isDisplayed()
);
driver.manage().window().setSize(
new Dimension(375, 812)
);
WebElement mobileMenu = driver.findElement(
By.id("mobileMenu")
);
System.out.println(
"Mobile Menu: " + mobileMenu.isDisplayed()
);
A displayed button may still be disabled.
WebElement submit = driver.findElement(By.id("submit"));
boolean visible = submit.isDisplayed();
boolean enabled = submit.isEnabled();
System.out.println("Visible: " + visible);
System.out.println("Enabled: " + enabled);
For a control that must both be visible and enabled:
if (submit.isDisplayed() && submit.isEnabled()) {
System.out.println("Submit is visible and enabled");
}
A checkbox or radio button can be displayed without being selected.
WebElement checkbox = driver.findElement(By.id("terms"));
boolean visible = checkbox.isDisplayed();
boolean selected = checkbox.isSelected();
System.out.println("Visible: " + visible);
System.out.println("Selected: " + selected);
An element being displayed does not guarantee that a click will always succeed. Other conditions can affect interaction, including overlays, animations, stale elements, application state, or click interception.
WebElement button = driver.findElement(By.id("submit"));
if (button.isDisplayed()) {
System.out.println("Button is displayed");
}
For click-oriented synchronization, an explicit wait such as elementToBeClickable() may be more appropriate.
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement button = wait.until(
ExpectedConditions.elementToBeClickable(
By.id("submit")
)
);
button.click();
This condition checks for the state needed for a typical click interaction, but it still does not guarantee that an application-specific overlay or event will never interfere with the click.
WebElement searchBox = driver.findElement(
By.id("search")
);
if (searchBox.isDisplayed()) {
searchBox.sendKeys("Selenium");
}
WebElement submit = driver.findElement(By.id("submit"));
boolean displayed = submit.isDisplayed();
boolean enabled = submit.isEnabled();
if (displayed && enabled) {
System.out.println(
"Submit button is displayed and enabled"
);
}
WebElement username = driver.findElement(By.id("username"));
WebElement password = driver.findElement(By.id("password"));
WebElement loginButton = driver.findElement(By.id("login"));
Assert.assertTrue(
username.isDisplayed(),
"Username field is not displayed"
);
Assert.assertTrue(
password.isDisplayed(),
"Password field is not displayed"
);
Assert.assertTrue(
loginButton.isDisplayed(),
"Login button is not displayed"
);
A practical Selenium project can use isDisplayed() to validate the visibility of important components throughout an application.
Open Browser
↓
Open Application
↓
Verify Logo
↓
Verify Navigation Menu
↓
Verify Login Form
↓
Enter Credentials
↓
Click Login
↓
Verify Dashboard
↓
Verify Success Message
↓
Open Product Page
↓
Verify Product Cards
↓
Verify Add to Cart Button
↓
Open Cart
↓
Verify Checkout Form
↓
Complete Test
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")
)
);
WebElement loginButton = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("login")
)
);
Assert.assertTrue(username.isDisplayed());
Assert.assertTrue(password.isDisplayed());
Assert.assertTrue(loginButton.isDisplayed());
username.sendKeys("testuser");
password.sendKeys("password");
loginButton.click();
WebElement dashboard = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("dashboard")
)
);
Assert.assertTrue(dashboard.isDisplayed());
| Advantage | Description |
|---|---|
| Simple | Easy to use and understand. |
| Boolean Result | Returns true or false for straightforward validation. |
| UI Validation | Useful for checking whether important elements are displayed. |
| Dynamic UI Testing | Useful for validating elements that appear or disappear. |
| Form Validation | Can verify that fields and messages are visible. |
| Regression Testing | Helps verify that expected UI components remain visible. |
| TestNG Integration | Can be combined easily with assertions. |
| Requirement | Recommended Method |
|---|---|
| Check displayed state | isDisplayed() |
| Check enabled state | isEnabled() |
| Check selected state | isSelected() |
| Wait for visibility | visibilityOfElementLocated() |
| Wait for an existing element to become visible | visibilityOf() |
| Wait for disappearance | invisibilityOfElementLocated() |
| Wait for clickability | elementToBeClickable() |
| Retrieve visible text | getText() |
| Retrieve attribute/property value | getAttribute() |
isDisplayed() is a WebElement method used to check whether an element is displayed. It returns a boolean value.
The return type is boolean.
true means that Selenium considers the element to be displayed according to WebDriver's visibility rules.
false means that the element is not displayed according to WebDriver's visibility rules.
No. isDisplayed() performs an immediate check. For dynamic elements, use an explicit wait such as visibilityOfElementLocated().
isDisplayed() checks displayed state, while isEnabled() checks whether an element is enabled for interaction.
isDisplayed() checks visibility, while isSelected() checks selected state, especially for checkboxes, radio buttons, and options.
Yes. For example:
Assert.assertTrue(element.isDisplayed());Yes. It can return false when the located element is not displayed.
No. findElement() locates an element in the DOM. The element can still be non-displayed.
WebDriverWait with ExpectedConditions.visibilityOfElementLocated() is commonly used.
boolean visible = element.isDisplayed();Assert.assertTrue(element.isDisplayed());Yes. Displayed state and enabled state are separate properties.
No. An element can be displayed but still be affected by overlays, animations, stale references, application state, or other interaction issues.
findElement() can throw NoSuchElementException when the requested element cannot be located.
StaleElementReferenceException can occur when a previously located WebElement is no longer attached to the current DOM.
wait.until(
ExpectedConditions.invisibilityOfElementLocated(
By.id("loader")
)
);
isDisplayed() is an important Selenium WebDriver method used to determine whether a web element is currently displayed. It returns a boolean value and can be used for validating buttons, forms, fields, messages, menus, images, popups, product cards, and other UI elements.
The method should be clearly distinguished from isEnabled() and isSelected(). isDisplayed() checks displayed state, isEnabled() checks enabled state, and isSelected() checks selection state.
For static pages, isDisplayed() can provide a simple immediate visibility check. For dynamic applications, explicit waits such as visibilityOfElementLocated() are generally more appropriate because they synchronize the test with the expected UI state.
Reliable Selenium automation should combine visibility checks with stable locators, explicit waits, appropriate assertions, proper exception handling, and Page Object Model practices.
JustAcademy's Selenium Training covers Selenium WebDriver, WebElements, locators, TestNG, automation frameworks, dynamic elements, practical testing, and real-time automation projects. Visit the JustAcademy Selenium Training Course to learn more. For a course demonstration, use the JustAcademy Course Demo Registration.
