Keyboard Actions in Selenium WebDriver are advanced keyboard interactions used to automate actions such as typing, pressing individual keys, using keyboard shortcuts, selecting text, copying and pasting content, navigating between elements, submitting forms, and interacting with applications that depend on keyboard events.
In Selenium Java, keyboard interactions are commonly performed using the Actions class together with Keys from org.openqa.selenium.Keys. Keyboard actions can be combined with mouse actions to create realistic and reusable browser automation workflows.
Selenium Training Course | Register for Course Demo
Keyboard Actions are automated keyboard operations performed against web elements or the active browser context. Selenium can simulate key presses such as Enter, Tab, Shift, Control, Alt, Escape, Arrow keys, Function keys, and many other keyboard inputs.
Actions actions = new Actions(driver);
actions.sendKeys(Keys.ENTER).perform();
Modern web applications often depend on keyboard events for navigation, shortcuts, form submission, accessibility, menus, search boxes, and rich user interfaces.
The Actions class provides methods for advanced mouse and keyboard interactions. It can create sequences involving keyboard keys, mouse movements, clicks, holds, releases, and other interactions.
Actions actions = new Actions(driver);The Keys class contains constants representing keyboard keys that can be used with Selenium keyboard interactions.
import org.openqa.selenium.Keys;Examples include Keys.ENTER, Keys.TAB, Keys.ESCAPE, Keys.SHIFT, Keys.CONTROL, Keys.ALT, and arrow keys.
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.interactions.Actions;
import org.openqa.selenium.Keys;
Actions actions = new Actions(driver);
actions.sendKeys(Keys.ENTER).perform();
The general workflow is:
Locate Element
↓
Create Actions Object
↓
Choose Keyboard Key
↓
Build Keyboard Action
↓
Perform Action
↓
Validate Result
The sendKeys() method can be used to send text or keyboard keys to the current active element.
new Actions(driver)
.sendKeys("Selenium Automation")
.perform();
WebElement searchBox = driver.findElement(
By.id("search")
);
new Actions(driver)
.click(searchBox)
.sendKeys("Selenium")
.perform();
For simple text input, WebElement.sendKeys() is often sufficient. The Actions API becomes particularly useful for advanced keyboard sequences and combinations.
WebElement username = driver.findElement(
By.id("username")
);
username.sendKeys("testuser");
| Feature | WebElement.sendKeys() | Actions.sendKeys() |
|---|---|---|
| Simple text input | Yes | Yes |
| Keyboard shortcuts | Limited | Yes |
| Active element interaction | Element-specific | Yes |
| Key combinations | Possible for element input | Better suited |
| Advanced sequences | Limited | Yes |
The Enter key is commonly used to submit forms, perform searches, confirm selections, or activate controls.
WebElement searchBox = driver.findElement(
By.id("search")
);
new Actions(driver)
.click(searchBox)
.sendKeys("Selenium")
.sendKeys(Keys.ENTER)
.perform();
The Tab key moves focus to the next focusable element.
new Actions(driver)
.sendKeys(Keys.TAB)
.perform();
Shift + Tab usually moves focus to the previous focusable element.
new Actions(driver)
.keyDown(Keys.SHIFT)
.sendKeys(Keys.TAB)
.keyUp(Keys.SHIFT)
.perform();
The Escape key is frequently used to close menus, dialogs, popups, dropdowns, and modal interfaces.
new Actions(driver)
.sendKeys(Keys.ESCAPE)
.perform();
The Space key can be used to activate focused controls such as checkboxes, buttons, or custom interactive elements.
new Actions(driver)
.sendKeys(Keys.SPACE)
.perform();
Arrow keys are useful for dropdowns, menus, sliders, calendars, custom controls, and keyboard navigation.
new Actions(driver)
.sendKeys(Keys.ARROW_DOWN)
.sendKeys(Keys.ARROW_DOWN)
.sendKeys(Keys.ENTER)
.perform();
new Actions(driver)
.sendKeys(Keys.ARROW_RIGHT)
.perform();
new Actions(driver)
.sendKeys(Keys.ARROW_LEFT)
.perform();
new Actions(driver)
.sendKeys(Keys.ARROW_UP)
.perform();
new Actions(driver)
.sendKeys(Keys.ARROW_DOWN)
.perform();
The Backspace key can be used to remove characters from an input field when the cursor is positioned appropriately.
new Actions(driver)
.sendKeys(Keys.BACK_SPACE)
.perform();
new Actions(driver)
.sendKeys(Keys.DELETE)
.perform();
The Home key can move the cursor to the beginning of a line or navigate to the beginning of a list depending on the application.
new Actions(driver)
.sendKeys(Keys.HOME)
.perform();
new Actions(driver)
.sendKeys(Keys.END)
.perform();
new Actions(driver)
.sendKeys(Keys.PAGE_UP)
.perform();
new Actions(driver)
.sendKeys(Keys.PAGE_DOWN)
.perform();
The Control key is commonly used for keyboard shortcuts such as Ctrl+A, Ctrl+C, Ctrl+V, and Ctrl+S.
new Actions(driver)
.keyDown(Keys.CONTROL)
.sendKeys("a")
.keyUp(Keys.CONTROL)
.perform();
The Shift key can be used to create uppercase characters, select text, and execute Shift-based shortcuts.
new Actions(driver)
.keyDown(Keys.SHIFT)
.sendKeys("selenium")
.keyUp(Keys.SHIFT)
.perform();
new Actions(driver)
.keyDown(Keys.ALT)
.sendKeys("a")
.keyUp(Keys.ALT)
.perform();
The Meta key can be relevant to platform-specific shortcuts, particularly on macOS.
new Actions(driver)
.keyDown(Keys.META)
.sendKeys("a")
.keyUp(Keys.META)
.perform();
The keyDown() method presses a modifier key and keeps it active until it is released.
new Actions(driver)
.keyDown(Keys.CONTROL)
.sendKeys("a")
.perform();
When a modifier is intentionally held, it should normally be released using keyUp().
The keyUp() method releases a previously pressed modifier key.
new Actions(driver)
.keyDown(Keys.CONTROL)
.sendKeys("a")
.keyUp(Keys.CONTROL)
.perform();
Ctrl+A is commonly used to select all text inside an input field.
WebElement input = driver.findElement(
By.id("username")
);
new Actions(driver)
.click(input)
.keyDown(Keys.CONTROL)
.sendKeys("a")
.keyUp(Keys.CONTROL)
.perform();
new Actions(driver)
.keyDown(Keys.CONTROL)
.sendKeys("c")
.keyUp(Keys.CONTROL)
.perform();
new Actions(driver)
.keyDown(Keys.CONTROL)
.sendKeys("v")
.keyUp(Keys.CONTROL)
.perform();
new Actions(driver)
.keyDown(Keys.CONTROL)
.sendKeys("x")
.keyUp(Keys.CONTROL)
.perform();
new Actions(driver)
.keyDown(Keys.CONTROL)
.sendKeys("z")
.keyUp(Keys.CONTROL)
.perform();
new Actions(driver)
.keyDown(Keys.CONTROL)
.sendKeys("y")
.keyUp(Keys.CONTROL)
.perform();
Applications with custom save shortcuts can be tested using keyboard combinations.
new Actions(driver)
.keyDown(Keys.CONTROL)
.sendKeys("s")
.keyUp(Keys.CONTROL)
.perform();
new Actions(driver)
.keyDown(Keys.CONTROL)
.sendKeys("f")
.keyUp(Keys.CONTROL)
.perform();
A common automation workflow is selecting existing text and replacing it with new content.
WebElement input = driver.findElement(
By.id("email")
);
new Actions(driver)
.click(input)
.keyDown(Keys.CONTROL)
.sendKeys("a")
.keyUp(Keys.CONTROL)
.sendKeys("[email protected]")
.perform();
Shift combined with arrow keys can select text in applications that support standard keyboard selection behavior.
new Actions(driver)
.keyDown(Keys.SHIFT)
.sendKeys(Keys.ARROW_RIGHT)
.sendKeys(Keys.ARROW_RIGHT)
.sendKeys(Keys.ARROW_RIGHT)
.keyUp(Keys.SHIFT)
.perform();
Keyboard navigation can be used to verify that users can move through a form using the Tab key.
new Actions(driver)
.sendKeys("John")
.sendKeys(Keys.TAB)
.sendKeys("[email protected]")
.sendKeys(Keys.TAB)
.sendKeys("1234567890")
.perform();
WebElement username = driver.findElement(
By.id("username")
);
username.sendKeys("testuser");
new Actions(driver)
.sendKeys(Keys.ENTER)
.perform();
WebElement search = driver.findElement(
By.name("q")
);
new Actions(driver)
.click(search)
.sendKeys("Selenium WebDriver")
.sendKeys(Keys.ENTER)
.perform();
WebElement username = driver.findElement(
By.id("username")
);
WebElement password = driver.findElement(
By.id("password")
);
new Actions(driver)
.click(username)
.sendKeys("testuser")
.sendKeys(Keys.TAB)
.sendKeys("Password123")
.sendKeys(Keys.ENTER)
.perform();
Custom dropdowns can sometimes be navigated using arrow keys and Enter.
WebElement dropdown = driver.findElement(
By.id("country")
);
new Actions(driver)
.click(dropdown)
.sendKeys(Keys.ARROW_DOWN)
.sendKeys(Keys.ARROW_DOWN)
.sendKeys(Keys.ENTER)
.perform();
Autocomplete fields often require typing text and selecting a suggestion using the keyboard.
WebElement city = driver.findElement(
By.id("city")
);
new Actions(driver)
.click(city)
.sendKeys("Mumbai")
.pause(Duration.ofMillis(500))
.sendKeys(Keys.ARROW_DOWN)
.sendKeys(Keys.ENTER)
.perform();
Escape can be used to close a custom modal or dialog when the application supports keyboard dismissal.
new Actions(driver)
.sendKeys(Keys.ESCAPE)
.perform();
Keyboard actions can be used to navigate custom menus using arrow keys and Enter.
new Actions(driver)
.sendKeys(Keys.ARROW_DOWN)
.sendKeys(Keys.ARROW_DOWN)
.sendKeys(Keys.ARROW_RIGHT)
.sendKeys(Keys.ENTER)
.perform();
A focused checkbox can often be toggled using the Space key.
WebElement checkbox = driver.findElement(
By.id("terms")
);
new Actions(driver)
.click(checkbox)
.sendKeys(Keys.SPACE)
.perform();
WebElement radio = driver.findElement(
By.id("male")
);
new Actions(driver)
.click(radio)
.sendKeys(Keys.SPACE)
.perform();
When a button has keyboard focus, Enter or Space may activate it depending on the control.
WebElement button = driver.findElement(
By.id("submit")
);
new Actions(driver)
.click(button)
.sendKeys(Keys.ENTER)
.perform();
WebElement textarea = driver.findElement(
By.id("comments")
);
new Actions(driver)
.click(textarea)
.sendKeys("This is a Selenium keyboard test.")
.perform();
For controls that interpret Enter as a newline, keyboard actions can create multiline input.
new Actions(driver)
.sendKeys("First line")
.sendKeys(Keys.ENTER)
.sendKeys("Second line")
.perform();
Rich text editors often use contenteditable elements and can require Actions-based keyboard input.
WebElement editor = driver.findElement(
By.cssSelector("[contenteditable='true']")
);
new Actions(driver)
.click(editor)
.sendKeys("Selenium keyboard automation")
.perform();
WebElement input = driver.findElement(
By.id("message")
);
new Actions(driver)
.click(input)
.keyDown(Keys.CONTROL)
.sendKeys("a")
.keyUp(Keys.CONTROL)
.perform();
A common keyboard approach is selecting all text and pressing Backspace.
new Actions(driver)
.keyDown(Keys.CONTROL)
.sendKeys("a")
.keyUp(Keys.CONTROL)
.sendKeys(Keys.BACK_SPACE)
.perform();
| Aspect | clear() | Keyboard Method |
|---|---|---|
| Simple input clearing | Yes | Yes |
| Simulates keyboard behavior | No | Yes |
| Keyboard event testing | Limited | Better suited |
| Shortcut support | No | Yes |
Dynamic elements should be synchronized before keyboard actions are performed.
WebDriverWait wait =
new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement search = wait.until(
ExpectedConditions.elementToBeClickable(
By.id("search")
)
);
new Actions(driver)
.click(search)
.sendKeys("Selenium")
.sendKeys(Keys.ENTER)
.perform();
import java.time.Duration;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
WebDriverWait wait =
new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement input = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.cssSelector(".dynamic-input")
)
);
new Actions(driver)
.click(input)
.sendKeys("Dynamic Element")
.perform();
If the target element is inside an iframe, Selenium must switch to that frame before performing keyboard actions on the element.
driver.switchTo().frame("loginFrame");
WebElement username = driver.findElement(
By.id("username")
);
new Actions(driver)
.click(username)
.sendKeys("testuser")
.perform();
driver.switchTo().defaultContent();
driver.switchTo().frame("outerFrame");
driver.switchTo().frame("innerFrame");
WebElement input = driver.findElement(
By.id("input")
);
new Actions(driver)
.click(input)
.sendKeys("Test Data")
.perform();
driver.switchTo().defaultContent();
Keyboard actions operate within the currently active browser window or tab. Selenium must switch to the required window before interacting with its elements.
driver.switchTo().window(windowHandle);
new Actions(driver)
.sendKeys(Keys.TAB)
.perform();
JavaScript alerts are handled through Selenium's Alert API rather than normal WebElement keyboard actions.
Alert alert = driver.switchTo().alert();
alert.sendKeys("Test Input");
alert.accept();
import org.openqa.selenium.Alert;Some browser-level shortcuts can behave differently across browsers, operating systems, browser configurations, or security restrictions. Application-level keyboard interactions should generally be the focus of automated tests.
When Actions.sendKeys() is used without explicitly clicking an element, the active element or current browser context receives the keyboard input.
new Actions(driver)
.sendKeys("Hello")
.perform();
Keyboard events depend heavily on focus. If the wrong element is focused, the keyboard action may be sent to an unexpected control.
JavaScript can be used to inspect which element currently has focus.
JavascriptExecutor js =
(JavascriptExecutor) driver;
WebElement activeElement =
(WebElement) js.executeScript(
"return document.activeElement;"
);
System.out.println(
activeElement.getAttribute("id")
);
A keyboard navigation test can verify whether focus moves through a form in the expected order.
WebElement username = driver.findElement(
By.id("username")
);
new Actions(driver)
.click(username)
.sendKeys("testuser")
.sendKeys(Keys.TAB)
.sendKeys("password")
.sendKeys(Keys.TAB)
.sendKeys(Keys.ENTER)
.perform();
Keyboard automation can help verify whether important application functions are reachable and usable through keyboard interaction.
new Actions(driver)
.click(firstField)
.sendKeys(Keys.TAB)
.sendKeys(Keys.TAB)
.sendKeys(Keys.TAB)
.perform();
WebElement search = driver.findElement(
By.id("search")
);
new Actions(driver)
.click(search)
.sendKeys("Selenium")
.pause(Duration.ofMillis(500))
.sendKeys(Keys.ARROW_DOWN)
.sendKeys(Keys.ENTER)
.perform();
Calendar widgets may use arrow keys to move between dates and Enter to select a date.
WebElement calendar = driver.findElement(
By.id("calendar")
);
new Actions(driver)
.click(calendar)
.sendKeys(Keys.ARROW_RIGHT)
.sendKeys(Keys.ARROW_RIGHT)
.sendKeys(Keys.ENTER)
.perform();
Accessible sliders may be controlled using arrow keys after the slider handle receives focus.
WebElement slider = driver.findElement(
By.cssSelector(".slider")
);
new Actions(driver)
.click(slider)
.sendKeys(Keys.ARROW_RIGHT)
.sendKeys(Keys.ARROW_RIGHT)
.sendKeys(Keys.ARROW_RIGHT)
.perform();
WebElement menu = driver.findElement(
By.id("menu")
);
new Actions(driver)
.click(menu)
.sendKeys(Keys.ARROW_DOWN)
.sendKeys(Keys.ARROW_DOWN)
.sendKeys(Keys.ENTER)
.perform();
WebElement input = driver.findElement(
By.id("location")
);
new Actions(driver)
.click(input)
.sendKeys("Mumbai")
.pause(Duration.ofMillis(500))
.sendKeys(Keys.ARROW_DOWN)
.sendKeys(Keys.ENTER)
.perform();
Rich text editors may support keyboard shortcuts for formatting, selection, indentation, and navigation.
WebElement editor = driver.findElement(
By.cssSelector("[contenteditable='true']")
);
new Actions(driver)
.click(editor)
.sendKeys("Important Text")
.keyDown(Keys.CONTROL)
.sendKeys("a")
.keyUp(Keys.CONTROL)
.perform();
The pause() method can introduce a short delay inside an Actions sequence when a specific application interaction requires it.
new Actions(driver)
.click(searchBox)
.sendKeys("Selenium")
.pause(Duration.ofMillis(500))
.sendKeys(Keys.ENTER)
.perform();
A fixed pause should not replace proper synchronization. Explicit waits are generally more appropriate when the application exposes a condition that can be observed.
Using arbitrary delays can make tests slower and less reliable.
Thread.sleep(3000);
new Actions(driver)
.sendKeys(Keys.ENTER)
.perform();
Prefer explicit waits when waiting for a known UI state.
After a keyboard interaction, the test should verify the resulting application state.
new Actions(driver)
.click(searchBox)
.sendKeys("Selenium")
.sendKeys(Keys.ENTER)
.perform();
WebElement result = new WebDriverWait(
driver,
Duration.ofSeconds(10)
).until(
ExpectedConditions.visibilityOfElementLocated(
By.id("results")
)
);
Assert.assertTrue(
result.isDisplayed(),
"Search results were not displayed"
);
@Test
public void verifySearchUsingKeyboard() {
WebElement search = driver.findElement(
By.id("search")
);
new Actions(driver)
.click(search)
.sendKeys("Selenium")
.sendKeys(Keys.ENTER)
.perform();
Assert.assertTrue(
driver.findElement(By.id("results"))
.isDisplayed()
);
}
import org.testng.Assert;
import org.testng.annotations.Test;
Keyboard interaction logic can be placed inside page objects so that test classes remain simple and readable.
public void searchUsingKeyboard(String text) {
WebElement search = driver.findElement(
By.id("search")
);
new Actions(driver)
.click(search)
.sendKeys(text)
.sendKeys(Keys.ENTER)
.perform();
}
public class SearchPage {
private WebDriver driver;
private By searchBox = By.id("search");
private By results = By.id("results");
public SearchPage(WebDriver driver) {
this.driver = driver;
}
public void search(String text) {
WebElement search =
driver.findElement(searchBox);
new Actions(driver)
.click(search)
.sendKeys(text)
.sendKeys(Keys.ENTER)
.perform();
}
public boolean isResultDisplayed() {
return driver.findElement(results)
.isDisplayed();
}
}
@Test
public void verifySearch() {
SearchPage page =
new SearchPage(driver);
page.search("Selenium");
Assert.assertTrue(
page.isResultDisplayed()
);
}
public class KeyboardUtils {
private WebDriver driver;
public KeyboardUtils(WebDriver driver) {
this.driver = driver;
}
public void pressEnter() {
new Actions(driver)
.sendKeys(Keys.ENTER)
.perform();
}
public void pressEscape() {
new Actions(driver)
.sendKeys(Keys.ESCAPE)
.perform();
}
public void pressTab() {
new Actions(driver)
.sendKeys(Keys.TAB)
.perform();
}
}
public void ctrlA() {
new Actions(driver)
.keyDown(Keys.CONTROL)
.sendKeys("a")
.keyUp(Keys.CONTROL)
.perform();
}
public void ctrlC() {
new Actions(driver)
.keyDown(Keys.CONTROL)
.sendKeys("c")
.keyUp(Keys.CONTROL)
.perform();
}
public void ctrlV() {
new Actions(driver)
.keyDown(Keys.CONTROL)
.sendKeys("v")
.keyUp(Keys.CONTROL)
.perform();
}
public void pressArrowDown(int count) {
Actions actions = new Actions(driver);
for (int i = 0; i < count; i++) {
actions.sendKeys(Keys.ARROW_DOWN);
}
actions.perform();
}
Keyboard shortcuts can differ between operating systems. For example, Control is commonly used on Windows/Linux, while Meta is commonly used for many equivalent shortcuts on macOS.
Keys modifier = Keys.CONTROL;
new Actions(driver)
.keyDown(modifier)
.sendKeys("a")
.keyUp(modifier)
.perform();
Keyboard interactions should be validated on the browsers supported by the application because browser behavior and application event handling can vary.
| Browser | Keyboard Validation |
|---|---|
| Chrome | Keyboard navigation and shortcuts |
| Firefox | Keyboard navigation and shortcuts |
| Edge | Keyboard navigation and shortcuts |
Keyboard interactions are generally less dependent on screen coordinates than mouse interactions, but focus behavior can still change depending on responsive layouts and application state.
Modern JavaScript applications can dynamically replace elements. When this occurs, locate the current element before performing the keyboard action.
WebDriverWait wait =
new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement input = wait.until(
ExpectedConditions.elementToBeClickable(
By.id("dynamicInput")
)
);
new Actions(driver)
.click(input)
.sendKeys("Test")
.perform();
NoSuchElementExceptionStaleElementReferenceExceptionElementNotInteractableExceptionElementClickInterceptedExceptionMoveTargetOutOfBoundsExceptionThis can occur when the target element is not currently available for interaction.
A stale element can occur when the DOM changes after an element was located. Re-locate the current element before performing the keyboard action.
WebDriverWait wait =
new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement input = wait.until(
ExpectedConditions.refreshed(
ExpectedConditions.elementToBeClickable(
By.id("input")
)
)
);
new Actions(driver)
.click(input)
.sendKeys("Test")
.perform();
When a keyboard interaction fails, check the following areas:
Actions class for advanced keyboard sequences.WebElement.sendKeys() for simple text input when appropriate.keyUp().Thread.sleep() unnecessarily.| Aspect | Keyboard Actions | JavaScript |
|---|---|---|
| Simulates user keyboard interaction | Yes | Not necessarily |
| Keyboard event testing | Suitable | Usually less suitable |
| Focus behavior | Can be tested | Can be manipulated directly |
| Realistic user interaction | Higher | Depends on implementation |
| Application keyboard shortcuts | Suitable | Usually not preferred |
try {
new Actions(driver)
.click(searchBox)
.sendKeys("Selenium")
.sendKeys(Keys.ENTER)
.perform();
} catch (Exception e) {
File screenshot =
((TakesScreenshot) driver)
.getScreenshotAs(OutputType.FILE);
System.out.println(
"Keyboard action failed: " + e.getMessage()
);
}
import java.io.File;
import org.openqa.selenium.OutputType;
import org.openqa.selenium.TakesScreenshot;
System.out.println("Clicking search box");
new Actions(driver)
.click(searchBox)
.perform();
System.out.println("Entering search text");
new Actions(driver)
.sendKeys("Selenium")
.perform();
System.out.println("Pressing Enter");
new Actions(driver)
.sendKeys(Keys.ENTER)
.perform();
Consider a login form where the tester wants to enter the username, move to the password field using Tab, and submit the form using Enter.
WebDriverWait wait =
new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement username = wait.until(
ExpectedConditions.elementToBeClickable(
By.id("username")
)
);
new Actions(driver)
.click(username)
.sendKeys("testuser")
.sendKeys(Keys.TAB)
.sendKeys("Password123")
.sendKeys(Keys.ENTER)
.perform();
WebElement dashboard = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("dashboard")
)
);
Assert.assertTrue(
dashboard.isDisplayed(),
"Dashboard was not displayed"
);
Automate a product search using only keyboard interaction after focusing the search field.
WebElement search = driver.findElement(
By.id("productSearch")
);
new Actions(driver)
.click(search)
.sendKeys("Laptop")
.sendKeys(Keys.ENTER)
.perform();
WebElement results = new WebDriverWait(
driver,
Duration.ofSeconds(10)
).until(
ExpectedConditions.visibilityOfElementLocated(
By.id("searchResults")
)
);
Assert.assertTrue(results.isDisplayed());
WebElement firstName = driver.findElement(
By.id("firstName")
);
new Actions(driver)
.click(firstName)
.sendKeys("John")
.sendKeys(Keys.TAB)
.sendKeys("Doe")
.sendKeys(Keys.TAB)
.sendKeys("[email protected]")
.sendKeys(Keys.TAB)
.sendKeys("1234567890")
.perform();
WebElement country = driver.findElement(
By.id("country")
);
new Actions(driver)
.click(country)
.sendKeys(Keys.ARROW_DOWN)
.sendKeys(Keys.ARROW_DOWN)
.sendKeys(Keys.ARROW_DOWN)
.sendKeys(Keys.ENTER)
.perform();
Test whether a user can navigate through important controls without relying on mouse clicks.
new Actions(driver)
.sendKeys(Keys.TAB)
.sendKeys(Keys.TAB)
.sendKeys(Keys.TAB)
.sendKeys(Keys.ENTER)
.perform();
Project: Keyboard-Based Login and Search Automation
Create an automation flow where the user logs into a web application using keyboard navigation and then performs a search using the keyboard.
@Test
public void verifyKeyboardLoginAndSearch() {
WebDriverWait wait =
new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement username = wait.until(
ExpectedConditions.elementToBeClickable(
By.id("username")
)
);
new Actions(driver)
.click(username)
.sendKeys("testuser")
.sendKeys(Keys.TAB)
.sendKeys("Password123")
.sendKeys(Keys.ENTER)
.perform();
WebElement dashboard = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("dashboard")
)
);
Assert.assertTrue(
dashboard.isDisplayed(),
"Dashboard was not displayed"
);
WebElement search = wait.until(
ExpectedConditions.elementToBeClickable(
By.id("search")
)
);
new Actions(driver)
.click(search)
.sendKeys("Selenium")
.sendKeys(Keys.ENTER)
.perform();
WebElement results = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("results")
)
);
Assert.assertTrue(
results.isDisplayed(),
"Search results were not displayed"
);
}
| Test Case ID | Scenario | Expected Result |
|---|---|---|
| TC-KEY-001 | Press Enter in search field | Search is submitted |
| TC-KEY-002 | Navigate using Tab | Focus moves to the next control |
| TC-KEY-003 | Use Shift + Tab | Focus moves to the previous control |
| TC-KEY-004 | Use Escape on modal | Modal closes when supported |
| TC-KEY-005 | Use Arrow keys in dropdown | Option navigation works |
| TC-KEY-006 | Use Ctrl+A | Text is selected |
| TC-KEY-007 | Use keyboard form navigation | Focus moves correctly |
| TC-KEY-008 | Submit login with Enter | Login is submitted |
| TC-KEY-009 | Use keyboard on accessible control | Control responds correctly |
| TC-KEY-010 | Keyboard shortcut | Application performs expected shortcut action |
Test Case ID: TC-KEY-001
Title: Verify Keyboard Action
Precondition: Application is available
Steps:
1. Open the application
2. Locate the required element
3. Give focus to the element
4. Perform the required keyboard action
5. Continue the keyboard sequence
6. Validate the application response
Expected Result:
The application should respond correctly to
the specified keyboard interaction.
Keyboard Actions are advanced keyboard interactions used to simulate keys, keyboard shortcuts, navigation, text selection, form submission, and other keyboard-based user interactions in Selenium WebDriver.
The org.openqa.selenium.interactions.Actions class is commonly used for advanced keyboard interactions.
The org.openqa.selenium.Keys class provides constants representing special keyboard keys such as Enter, Tab, Shift, Control, Escape, and Arrow keys.
keyDown() presses and holds a modifier key, while keyUp() releases that modifier key.
new Actions(driver)
.keyDown(Keys.CONTROL)
.sendKeys("a")
.keyUp(Keys.CONTROL)
.perform();
new Actions(driver)
.sendKeys(Keys.ENTER)
.perform();
new Actions(driver)
.sendKeys(Keys.TAB)
.perform();
new Actions(driver)
.keyDown(Keys.CONTROL)
.sendKeys("a")
.keyUp(Keys.CONTROL)
.perform();
new Actions(driver)
.keyDown(Keys.CONTROL)
.sendKeys("c")
.keyUp(Keys.CONTROL)
.keyDown(Keys.CONTROL)
.sendKeys("v")
.keyUp(Keys.CONTROL)
.perform();
Keyboard events are delivered according to the active focus context. If the wrong element is focused, the keyboard action may be applied to the wrong control.
Yes. The Actions class can combine mouse and keyboard operations into a single action sequence.
new Actions(driver)
.moveToElement(element)
.click()
.keyDown(Keys.CONTROL)
.sendKeys("a")
.keyUp(Keys.CONTROL)
.sendKeys("New Text")
.perform();
The perform() method executes the built Actions sequence.
new Actions(driver)
.sendKeys(Keys.ENTER)
.perform();
Actions class supports advanced keyboard sequences.Keys class provides keyboard key constants.sendKeys() to send text or special keys.keyDown() to press and hold a modifier.keyUp() to release a modifier.Keys.ENTER for Enter.Keys.TAB for Tab.Keys.ESCAPE for Escape.Keys.ARROW_DOWN and other arrow keys for navigation.Launch Browser
↓
Open Application
↓
Locate Element
↓
Wait Until Ready
↓
Give Element Focus
↓
Create Actions Object
↓
Press Required Key
↓
Use Modifier if Required
↓
Release Modifier
↓
Perform Action
↓
Wait for UI Response
↓
Validate Result
Keyboard Actions are an important part of Selenium WebDriver automation because many modern web applications depend on keyboard navigation, shortcuts, form submission, text editing, dropdown navigation, dialogs, menus, sliders, and accessibility features.
The Selenium Actions class provides powerful methods such as sendKeys(), keyDown(), keyUp(), click(), and other interaction methods that can be combined to create realistic keyboard workflows.
Reliable keyboard automation should use stable locators, correct focus management, explicit waits for dynamic elements, proper modifier-key handling, iframe switching when required, and assertions that verify the actual application result.
Recommended Selenium Learning Resources:
