Validation Before Interaction – How Selenium Decides When It Can Click

Understand how Selenium checks if an element is really clickable before performing actions.

Concept

Before Selenium calls click() or sendKeys(), it doesn’t just “trust” the DOM. It tries to behave like a real user and asks: Can a human actually interact with this element right now?

Selenium WebElement commands (click(), sendKeys(), etc.) include built-in safety checks.
The low-level Actions API can bypass some of these checks and act directly on coordinates.
If something is wrong, Selenium throws interactability exceptions instead of performing fake, unrealistic clicks.

WebElement Interaction Commands

Methods like click(), sendKeys(), and clear() validate that the element is interactable:

It is visible.
It is enabled (for controls).
It is not covered by another element.

Best Practice

Prefer WebElement commands for standard interactions. If you get an exception, treat it as a signal that the UI is not really ready yet.

Low-level Actions API

The Actions API allows moving the mouse to coordinates and clicking, but it does not perform the same level of checks.

It sends events to specific coordinates, even if the target is off-screen or covered.

Use with Caution

Treat Actions as a power tool. Make sure the element is visible and unobstructed before firing low-level actions.

The Three Interactability Checks

1. Visibility: Element must not be display: none or visibility: hidden and must have a non-zero size.
2. Enabled: Controls must be enabled. Disabled elements are present in the DOM but not interactive.
3. Unobstructed: Element must not be covered by overlays, modals, or sticky headers. If covered, Selenium throws an interception exception.

Interactive Practice

Interactability Lab

State Selector:

Current State: normal

Interact with the state buttons to see how the "Click Me!" button behaves. Use Selenium to try clicking it in different states!

Java Code Example

InteractabilityTest.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
WebElement normalStateButton = driver.findElement(
        By.xpath("//button[contains(text(),'Normal (Interactable)')]"));
normalStateButton.click();

WebElement testButton = driver.findElement(By.id("test-button"));
testButton.click();

WebElement hiddenStateButton = driver.findElement(
        By.xpath("//button[contains(text(),'Hidden')]"));
hiddenStateButton.click();

WebElement disabledStateButton = driver.findElement(
        By.xpath("//button[contains(text(),'Disabled')]"));
disabledStateButton.click();

WebElement coveredStateButton = driver.findElement(
        By.xpath("//button[contains(text(),'Covered')]"));
coveredStateButton.click();

testButton = driver.findElement(By.id("test-button"));
testButton.click();

driver.quit();

Code Breakdown

normalStateButton.click(): Switches the demo into the normal, fully interactable state.
testButton.click(): Tries to click the test button. In the normal state, this should succeed.
hiddenStateButton.click(): Selects the button that turns the test button hidden.
disabledStateButton.click(): Switches the test button into a disabled state (still in the DOM, but not interactable).
coveredStateButton.click(): Activates the covered state, where an overlay sits on top of the test button.
testButton = driver.findElement(...): Re-locates the test button after state changes, reflecting that the DOM or layout may have changed.

Pro Tip

Read Errors Correctly

When you see "element not interactable" or "element click intercepted", read them as "a real user couldn’t click this right now", not as "Selenium is broken".

Check Before Clicking

Use simple checks like isDisplayed() and isEnabled() before calling click() on tricky elements.

Use Stable Locators

Prefer stable, readable locators (id, clear xpath) when working with dynamic states to make debugging easier.