The click() method in Selenium WebDriver is used to perform a click action on a web element. It is one of the most commonly used WebElement interaction methods in Selenium automation. Testers use click() to interact with buttons, links, checkboxes, radio buttons, menus, search buttons, submit buttons, navigation elements, and other clickable elements.
In a Selenium automation script, the usual process is to first locate a web element using a locator such as ID, Name, Class Name, XPath, CSS Selector, Link Text, or Partial Link Text and then call the click() method on the located element.
JustAcademy's Selenium Automation Testing course covers Selenium WebDriver, locators, web elements, browser automation, forms, buttons, waits, TestNG, Page Object Model, and practical automation projects. Explore Selenium Training at JustAcademy.
You can also visit JustAcademy Course Demo Registration to explore the course demo.
The click() method is a Selenium WebElement method used to simulate a normal click interaction on a web element.
For example, if a webpage contains a Login button, Selenium can locate the Login button and perform a click operation.
driver.findElement(By.id("login")).click();In this statement:
element.click();Another commonly used form is:
driver.findElement(By.id("button")).click();The first approach is useful when the element is already stored in a WebElement variable, while the second approach directly locates and clicks the element.
The basic Selenium click workflow is:
Start
↓
Launch Browser
↓
Open Web Application
↓
Locate Web Element
↓
Verify Element
↓
Perform click()
↓
Application Processes Click
↓
Expected Action Occurs
↓
Verify Result
↓
Continue Test
For example, a login workflow can be represented as:
Enter Username
↓
Enter Password
↓
Locate Login Button
↓
Click Login Button
↓
Application Validates Credentials
↓
Dashboard Opens
↓
Verify Dashboard
Suppose the HTML page contains:
<button id="login">Login</button>Selenium code:
driver.findElement(By.id("login")).click();Selenium locates the button using the ID login and performs the click action.
If an element has a unique ID, the ID locator can be used to locate the element.
driver.findElement(By.id("submit")).click();HTML:
<button id="submit">Submit</button>ID-based locators are generally simple and readable when the application provides stable unique IDs.
The name attribute can also be used to locate a clickable element.
driver.findElement(By.name("login")).click();HTML:
<button name="login">Login</button>The class name locator can be used when a suitable class identifies the element.
driver.findElement(By.className("login-button")).click();HTML:
<button class="login-button">Login</button>If an element contains multiple classes, By.className() should receive one individual class name rather than a complete space-separated class attribute.
XPath is frequently used when an element does not have a convenient unique ID or when a more flexible locator is required.
driver.findElement(By.xpath("//button[@id='login']")).click();Clicking an element using its visible text:
driver.findElement(By.xpath("//button[text()='Login']")).click();Using contains():
driver.findElement(By.xpath("//button[contains(text(),'Login')]")).click();Using normalize-space():
driver.findElement(By.xpath("//button[normalize-space()='Login']")).click();CSS selectors can also be used to locate clickable elements.
driver.findElement(By.cssSelector("#login")).click();Using a class:
driver.findElement(By.cssSelector(".login-button")).click();Using an attribute:
driver.findElement(By.cssSelector("button[type='submit']")).click();Selenium provides By.linkText() for locating links using their complete visible text.
driver.findElement(By.linkText("Login")).click();HTML:
<a href="/login">Login</a>By.partialLinkText() can be used when only part of the link text is known.
driver.findElement(By.partialLinkText("Login")).click();HTML:
<a href="/login">Login to Account</a>Buttons are among the most common elements used with click().
driver.findElement(By.id("submitButton")).click();Common button operations include:
A link can be clicked after locating it using different locator strategies.
driver.findElement(By.linkText("Home")).click();XPath:
driver.findElement(By.xpath("//a[text()='Home']")).click();CSS:
driver.findElement(By.cssSelector("a[href='/home']")).click();The click() method can be used to select or deselect a checkbox.
driver.findElement(By.id("terms")).click();HTML:
<input type="checkbox" id="terms">
<label for="terms">I agree to the terms</label>
To select the checkbox only when it is not already selected:
WebElement checkbox = driver.findElement(By.id("terms"));
if (!checkbox.isSelected()) {
checkbox.click();
}
Radio buttons can also be selected using click().
WebElement maleRadio = driver.findElement(By.id("male"));
if (!maleRadio.isSelected()) {
maleRadio.click();
}
HTML:
<input type="radio" id="male" name="gender">
<label for="male">Male</label>
The element can be stored in a WebElement variable before clicking it.
WebElement loginButton = driver.findElement(By.id("login"));
loginButton.click();
This approach can improve readability and can be useful when the same element is referenced multiple times.
| Approach | Example | Usage |
|---|---|---|
| Direct Click | driver.findElement(By.id("login")).click(); | Simple one-time interaction |
| WebElement Click | WebElement button = driver.findElement(By.id("login")); button.click(); | Useful when storing or reusing the element |
Modern web applications often load elements dynamically. A button may be present in the DOM but may not yet be ready for interaction. An explicit wait can be used to wait for the element to become clickable.
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement loginButton = wait.until(
ExpectedConditions.elementToBeClickable(By.id("login"))
);
loginButton.click();
The elementToBeClickable() expected condition is commonly used when the test needs to wait for an element to become suitable for clicking.
A click may fail if the page is still loading, an element is covered by another element, or the application has not reached the required state.
Without synchronization:
driver.findElement(By.id("login")).click();With explicit synchronization:
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement loginButton = wait.until(
ExpectedConditions.elementToBeClickable(By.id("login"))
);
loginButton.click();
Using an appropriate wait condition can make tests more stable than relying on fixed delays.
You can check whether an element is displayed before interacting with it.
WebElement button = driver.findElement(By.id("submit"));
if (button.isDisplayed()) {
button.click();
}
However, an element being displayed does not necessarily mean that it is ready to receive a click. Application state and synchronization should also be considered.
Some buttons remain disabled until the user completes required fields.
WebElement button = driver.findElement(By.id("submit"));
if (button.isEnabled()) {
button.click();
}
This can be useful when the application dynamically enables or disables a button.
| Exception | Possible Reason | Possible Approach |
|---|---|---|
| NoSuchElementException | Element cannot be located | Verify locator and page state |
| ElementNotInteractableException | Element is not currently interactable | Check visibility, state, and synchronization |
| ElementClickInterceptedException | Another element is blocking the click | Handle overlays, popups, or synchronization |
| StaleElementReferenceException | Element reference is no longer valid | Locate the element again |
| TimeoutException | Expected condition was not met | Check locator, page state, and wait configuration |
ElementClickInterceptedException can occur when Selenium tries to click an element but another element receives or blocks the intended interaction.
Possible causes include:
For example:
driver.findElement(By.id("submit")).click();If another element is blocking the button, the click may fail. The correct solution is to identify the blocking condition and handle it appropriately.
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement submitButton = wait.until(
ExpectedConditions.elementToBeClickable(By.id("submit"))
);
submitButton.click();
If an overlay is responsible for the problem, the test may also need to wait for the overlay to disappear before clicking the target element.
This exception may occur when Selenium has located an element but the element cannot currently be interacted with.
Possible causes include:
A typical login automation flow can be implemented using click().
driver.findElement(By.id("username")).sendKeys("admin");
driver.findElement(By.id("password")).sendKeys("admin123");
driver.findElement(By.id("login")).click();
The workflow is:
A submit button can trigger form submission.
driver.findElement(By.id("submit")).click();Example HTML:
<form>
<input id="name" type="text">
<button id="submit" type="submit">Submit</button>
</form>
A common automation scenario is entering a search term and clicking the Search button.
driver.findElement(By.id("search")).sendKeys("Selenium");
driver.findElement(By.id("searchButton")).click();
The expected flow is:
Enter Search Term
↓
Click Search
↓
Application Processes Request
↓
Search Results Displayed
↓
Verify Results
Navigation links can be clicked to move between pages.
driver.findElement(By.linkText("Products")).click();After clicking the link, the test can verify the resulting page.
String title = driver.getTitle();
System.out.println(title);
For custom dropdowns, click() can be used to open the dropdown before selecting an option.
driver.findElement(By.id("countryDropdown")).click();
driver.findElement(By.xpath("//li[normalize-space()='India']")).click();
For a standard HTML select element, Selenium's Select class is generally used instead of treating it like a custom dropdown.
Modern applications may generate dynamic IDs, classes, or other attributes. In such cases, a stable locator strategy and synchronization are important.
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement addToCart = wait.until(
ExpectedConditions.elementToBeClickable(
By.xpath("//button[contains(@class,'add-to-cart')]")
)
);
addToCart.click();
Dynamic XPath techniques such as contains(), starts-with(), and stable attribute combinations can help locate elements when some attributes change.
When text contains unnecessary or inconsistent whitespace, XPath's normalize-space() function can be useful.
driver.findElement(
By.xpath("//button[normalize-space()='Login']")
).click();
An element can sometimes be located through its relationship with a parent element.
driver.findElement(
By.xpath("//div[@class='login-container']//button")
).click();
This approach can be useful when the button does not have a unique attribute but its parent container provides a stable identification point.
XPath axes can be used to locate an element relative to another element.
driver.findElement(
By.xpath("//label[normalize-space()='Login']/following::button[1]")
).click();
Such relationships can be useful when direct attributes are insufficient for creating a stable locator.
Selenium's normal WebElement click() should generally be considered first for standard user interactions. In specific situations where the native interaction cannot be completed, JavaScript can be used as an alternative technique.
WebElement button = driver.findElement(By.id("submit"));
JavascriptExecutor js = (JavascriptExecutor) driver;
js.executeScript("arguments[0].click();", button);
JavaScript click should not automatically replace native click(). Before using it, investigate issues such as incorrect locators, synchronization, overlays, frames, or application state.
| Feature | WebElement click() | JavaScript Click |
|---|---|---|
| Syntax | element.click() | executeScript() |
| Interaction | WebDriver element interaction | JavaScript execution |
| Normal Usage | Standard web element interaction | Specific exceptional situations |
| Behavior | Closer to normal WebDriver interaction | Can bypass some normal UI interaction behavior |
| Debugging | Useful for detecting actual interaction problems | May hide some UI interaction issues |
The Selenium Actions class provides APIs for advanced mouse and keyboard interactions.
WebElement button = driver.findElement(By.id("submit"));
Actions actions = new Actions(driver);
actions.click(button).perform();
The Actions class can also be used for operations such as double-click, right-click, hover, drag and drop, and combined keyboard-mouse actions.
| Feature | WebElement click() | Actions click() |
|---|---|---|
| Syntax | element.click() | actions.click(element).perform() |
| Purpose | Normal click interaction | Advanced user interaction |
| Class | WebElement | Actions |
| Typical Usage | Buttons, links, checkboxes | Complex mouse interaction sequences |
A double-click is different from a normal click and can be performed using the Actions class.
WebElement element = driver.findElement(By.id("item"));
Actions actions = new Actions(driver);
actions.doubleClick(element).perform();
A context click can be used when the application requires a right-click interaction.
WebElement element = driver.findElement(By.id("item"));
Actions actions = new Actions(driver);
actions.contextClick(element).perform();
Sometimes a page layout or application behavior requires the target element to be brought into view before interaction.
WebElement button = driver.findElement(By.id("submit"));
((JavascriptExecutor) driver).executeScript(
"arguments[0].scrollIntoView(true);", button
);
button.click();
Scrolling should not be added automatically for every click. First determine whether the actual problem is caused by synchronization, overlays, or another UI condition.
If the clickable element is inside an iframe, Selenium must first switch to that frame.
driver.switchTo().frame("paymentFrame");
driver.findElement(By.id("pay")).click();
driver.switchTo().defaultContent();
The basic flow is:
Main Page
↓
Switch to iframe
↓
Locate Element
↓
Click Element
↓
Return to Main Document
If clicking an element opens a new window or tab, Selenium may need to switch to the appropriate window before continuing.
String parentWindow = driver.getWindowHandle();
driver.findElement(By.id("openWindow")).click();
for (String window : driver.getWindowHandles()) {
if (!window.equals(parentWindow)) {
driver.switchTo().window(window);
break;
}
}
Some buttons display JavaScript alerts after they are clicked.
driver.findElement(By.id("delete")).click();
Alert alert = driver.switchTo().alert();
alert.accept();
The sequence is:
Click Button
↓
Alert Appears
↓
Switch to Alert
↓
Accept or Dismiss
↓
Continue Test
HTML-based modal dialogs can be handled by locating their buttons after the modal appears.
driver.findElement(By.id("delete")).click();
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement confirmButton = wait.until(
ExpectedConditions.elementToBeClickable(By.id("confirmDelete"))
);
confirmButton.click();
In the Page Object Model, page elements and their actions can be maintained inside page classes.
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 void enterUsername(String value) {
driver.findElement(username).sendKeys(value);
}
public void enterPassword(String value) {
driver.findElement(password).sendKeys(value);
}
public void clickLogin() {
driver.findElement(loginButton).click();
}
}
Test class:
LoginPage loginPage = new LoginPage(driver);
loginPage.enterUsername("admin");
loginPage.enterPassword("admin123");
loginPage.clickLogin();
PageFactory can be used to declare WebElements using annotations.
public class LoginPage {
WebDriver driver;
@FindBy(id = "login")
WebElement loginButton;
public LoginPage(WebDriver driver) {
this.driver = driver;
PageFactory.initElements(driver, this);
}
public void clickLogin() {
loginButton.click();
}
}
Click operations are frequently used inside TestNG test methods.
@Test
public void loginTest() {
driver.findElement(By.id("username")).sendKeys("admin");
driver.findElement(By.id("password")).sendKeys("admin123");
driver.findElement(By.id("login")).click();
}
After performing a click, the test should generally verify the expected application behavior.
driver.findElement(By.id("login")).click();
String title = driver.getTitle();
Assert.assertTrue(title.contains("Dashboard"));
The click performs the interaction, while the assertion verifies the expected result.
Click operations are commonly used in end-to-end e-commerce automation.
driver.findElement(By.id("search")).sendKeys("Laptop");
driver.findElement(By.id("searchButton")).click();
driver.findElement(By.xpath("//button[contains(text(),'Add to Cart')]")).click();
driver.findElement(By.id("cart")).click();
driver.findElement(By.id("checkout")).click();
Flow:
Search Product
↓
Click Search
↓
View Search Results
↓
Click Add to Cart
↓
Open Cart
↓
Click Checkout
A registration test can contain several click operations.
driver.findElement(By.id("firstName")).sendKeys("John");
driver.findElement(By.id("lastName")).sendKeys("Smith");
driver.findElement(By.id("email")).sendKeys("[email protected]");
driver.findElement(By.id("terms")).click();
driver.findElement(By.id("register")).click();
Logout functionality can also be automated using click().
driver.findElement(By.id("profile")).click();
driver.findElement(By.id("logout")).click();
The test should then verify that the application has returned to the expected logged-out state.
In real-world Selenium projects, click() is normally combined with locators, waits, assertions, page objects, and test frameworks.
Open Application
↓
Locate Username
↓
Enter Username
↓
Locate Password
↓
Enter Password
↓
Wait for Login Button
↓
Click Login
↓
Wait for Dashboard
↓
Verify Dashboard
↓
Continue Test
The following example demonstrates a login workflow using WebDriver, WebElement, explicit wait, and click().
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 ClickExample {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
driver.manage().window().maximize();
driver.get("https://example.com");
driver.findElement(By.id("username"))
.sendKeys("admin");
driver.findElement(By.id("password"))
.sendKeys("admin123");
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement loginButton = wait.until(
ExpectedConditions.elementToBeClickable(
By.id("login")
)
);
loginButton.click();
driver.quit();
}
}
| Task | Example |
|---|---|
| Click by ID | driver.findElement(By.id("login")).click(); |
| Click by Name | driver.findElement(By.name("login")).click(); |
| Click by Class | driver.findElement(By.className("button")).click(); |
| Click by XPath | driver.findElement(By.xpath("//button[@id='login']")).click(); |
| Click by CSS | driver.findElement(By.cssSelector("#login")).click(); |
| Click by Link Text | driver.findElement(By.linkText("Login")).click(); |
| Click by Partial Link Text | driver.findElement(By.partialLinkText("Log")).click(); |
| Actions Click | new Actions(driver).click(element).perform(); |
| Double Click | new Actions(driver).doubleClick(element).perform(); |
| Right Click | new Actions(driver).contextClick(element).perform(); |
The click() method is a WebElement method used to perform a click interaction on a web element.
driver.findElement(By.id("submit")).click();Yes. click() can be used to select or deselect a checkbox. The selected state can be checked using isSelected().
Yes. After locating the link as a WebElement, click() can be used to activate it.
It can occur when another element blocks or intercepts the intended click interaction.
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement button = wait.until(
ExpectedConditions.elementToBeClickable(By.id("submit"))
);
button.click();
click() performs a click interaction, while sendKeys() is commonly used to enter keyboard input into an element.
WebElement click() performs a standard element interaction, while Actions.click() belongs to Selenium's advanced user interaction API.
It can be considered for specific cases where the normal WebDriver interaction cannot be completed after investigating the underlying UI or synchronization issue.
A successful click interaction does not by itself prove that the expected application behavior occurred. Assertions or other validations can verify the resulting state.
The click() method is a fundamental Selenium WebDriver operation for interacting with buttons, links, checkboxes, radio buttons, menus, forms, and other clickable elements. Reliable click automation requires more than simply calling click(); testers should also use stable locators, appropriate synchronization, correct frame or window context, proper handling of overlays and dynamic elements, and validation of the expected result.
For structured Selenium learning covering WebDriver, locators, web elements, waits, TestNG, Page Object Model, frameworks, and practical automation projects, visit JustAcademy Selenium Training.
For the course demo, visit JustAcademy Course Demo Registration.
