What is Alert in Selenium?

An alert in Selenium is a JavaScript pop-up box that appears over the browser and requires user interaction before the test can continue. Because alerts are not part of the DOM, they cannot be located like normal elements; instead, Selenium WebDriver provides a dedicated Alert interface, accessed through driver.switchTo().alert(), to accept, dismiss, read, or type into them.

Alerts are common in web applications for notifications, confirmations, and user input. Handling them correctly is essential, because an unhandled alert blocks execution and causes the next Selenium command to fail. This guide covers the alert types, the Alert interface methods, and how to handle each type reliably.

A JavaScript alert is a native browser dialog triggered by functions like alert(), confirm(), or prompt(). Since these dialogs sit above the page rather than inside the HTML, WebDriver cannot use findElement to reach them. Instead you shift the driver's focus to the alert, perform an action, and control returns to the main window. For a complete reference, see the TestMu AI guide on alerts in Selenium.

Selenium recognizes three types of JavaScript alerts, each requiring slightly different handling:

• Simple alert: Displays a message with a single OK button. Used for notifications and warnings that only need acknowledgement.
• Confirmation alert: Asks the user to confirm or cancel an action with OK and Cancel buttons, returning true or false to the page.
• Prompt alert: Contains a text input field along with OK and Cancel buttons, allowing the user to submit data back to the application.

The Alert interface exposes four core methods that map directly to user actions on a pop-up:

• accept(): Clicks the OK button to accept the alert.
• dismiss(): Clicks the Cancel button to dismiss the alert.
• getText(): Returns the message text displayed inside the alert, useful for validation.
• sendKeys(String): Types text into a prompt alert before accepting it.

The reliable pattern is to switch focus to the alert, then act on it. Here is a Java example that handles all three alert types:

import org.openqa.selenium.Alert;
import org.openqa.selenium.WebDriver;

// Simple alert: read the message, then accept
Alert simpleAlert = driver.switchTo().alert();
String message = simpleAlert.getText();
System.out.println("Alert text: " + message);
simpleAlert.accept();

// Confirmation alert: dismiss (click Cancel)
Alert confirmAlert = driver.switchTo().alert();
confirmAlert.dismiss();

// Prompt alert: type input, then accept (click OK)
Alert promptAlert = driver.switchTo().alert();
promptAlert.sendKeys("LambdaTest");
promptAlert.accept();

Notice that every interaction starts with driver.switchTo().alert(). After accept() or dismiss(), focus automatically returns to the main browser window, so your next command runs against the page as normal.

If your code tries to switch to an alert that has not yet appeared or has already been closed, Selenium throws a NoAlertPresentException. The fix is to wait explicitly for the alert to be present before interacting with it:

import java.time.Duration;
import org.openqa.selenium.Alert;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;

WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
Alert alert = wait.until(ExpectedConditions.alertIsPresent());
alert.accept();

Using ExpectedConditions.alertIsPresent() with a WebDriverWait pauses the script until the alert actually appears, making tests far more stable than immediately calling switchTo().alert().

• Treating alerts as elements: Trying to locate an alert with findElement fails because alerts are not in the DOM. Always use the Alert interface.
• Not waiting for the alert: Switching immediately after the trigger click can raise NoAlertPresentException. Use an explicit wait with alertIsPresent().
• Leaving an alert open: An unhandled alert blocks all further commands. Always accept or dismiss it before continuing.
• Wrong sendKeys usage: sendKeys only works on prompt alerts. Calling it on a simple or confirmation alert throws an error.
• Ignoring UnexpectedAlertPresentException: An alert appearing at an unexpected time can break other steps. Handle stray alerts defensively with try-catch blocks.

Different browsers render and time JavaScript alerts slightly differently, which can make alert handling flaky if you only test locally. Running your Selenium suite on TestMu AI across 3000+ real browsers, browser versions, and operating systems ensures alert handling behaves consistently everywhere your users are.

By executing alert-handling tests on a scalable cloud Selenium automation grid and pairing them with cross browser testing, you catch timing and rendering differences early instead of discovering them in production.

Alerts in Selenium are JavaScript pop-ups that must be handled through the Alert interface rather than standard element locators. By knowing the three alert types, using accept, dismiss, getText, and sendKeys correctly, and guarding against NoAlertPresentException with explicit waits, you can automate pop-up interactions reliably. Validating that behavior across real browsers ensures your alert handling stays consistent for every user.

What is an alert in Selenium?

An alert in Selenium is a JavaScript pop-up that appears over the browser and requires user interaction. Because alerts are not part of the DOM, you must use the Alert interface via driver.switchTo().alert() to interact with them rather than normal element locators.

How many types of alerts are there in Selenium?

There are three types of alerts in Selenium: simple alerts that show a message with an OK button, confirmation alerts with OK and Cancel buttons, and prompt alerts that also include a text field for user input.

How do you handle an alert in Selenium?

Switch focus to the alert using driver.switchTo().alert(), then call accept() to click OK, dismiss() to click Cancel, getText() to read the message, or sendKeys() to type into a prompt. Always switch to the alert before interacting with it.

What is NoAlertPresentException in Selenium?

NoAlertPresentException is thrown when Selenium tries to interact with an alert that is not present or has already been closed. The fix is to use an explicit wait with ExpectedConditions.alertIsPresent() before switching to the alert.

Are alerts part of the DOM in Selenium?

No. JavaScript alerts, confirms, and prompts are browser-level pop-ups that are not part of the HTML DOM. That is why they cannot be located with findElement and must be handled through the dedicated Alert interface.

Can you read the text of an alert in Selenium?

Yes. After switching to the alert with driver.switchTo().alert(), call getText() to capture the displayed message. This is commonly used to assert that the correct confirmation or warning text appears during a test.

• Why Can Selenium Not Handle Alerts, Pop-ups, and Other Web Page Elements?
• What is Selenium WebDriver?
• How to Make Another Window in Selenium?
• What is AutoIt in Selenium?
• How Can We Get Text on a Web Element Using Selenium?