How to Handle Modal Dialog Boxes in Selenium WebDriver with Java

For a native JavaScript alert(), confirm(), or prompt() dialog, switch to Selenium’s Alert handle, inspect the message with getText(), then call accept(), dismiss(), or sendKeys() as the test requires. If the dialog appears after an action, wait for ExpectedConditions.alertIsPresent() before accessing it.

An HTML modal made from page elements is different: find and operate its buttons and fields with ordinary WebDriver element methods. switchTo().alert() is for the browser’s native JavaScript dialog, not page markup.

1. Identify the kind of modal

Dialog	What to do
JavaScript alert	Read its message if needed, then acknowledge with accept().
JavaScript confirm	Use accept() for the affirmative branch or dismiss() for cancellation.
JavaScript prompt	Use sendKeys(value) and then accept() to submit, or dismiss() to cancel.
beforeunload prompt	Check the browser and driver’s unhandledPromptBehavior configuration; recent drivers dismiss these automatically by default.
HTML page modal	Locate its elements and interact with them as regular page content.

Selenium documents its Alert API for the three native JavaScript popup types. Native dialogs have browser-controlled appearance and limited customization. Selenium: JavaScript alerts, prompts and confirmations.

2. Handle an alert synchronously

Once an action has opened a native dialog, obtain its handle from the current window’s target locator. This standalone method assumes that the dialog is already present:

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

static String readAndAcceptAlert(WebDriver driver) {
    Alert alert = driver.switchTo().alert();
    String message = alert.getText();
    alert.accept();
    return message;
}

Call it after the action that triggers the alert, then assert the returned text or the resulting page state. getText() reads the dialog message. The handle represents the currently active modal dialog, so use it before triggering another dialog or changing the relevant browser context.

3. Wait for a dialog that appears after an action

Dialogs may appear only after the browser processes a click or other action. Use an explicit wait instead of an arbitrary sleep. This example uses the Java Duration-based WebDriverWait constructor:

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

static Alert waitForAlert(WebDriver driver, Duration timeout) {
    WebDriverWait wait = new WebDriverWait(driver, timeout);
    return wait.until(ExpectedConditions.alertIsPresent());
}

// After the application action that triggers the dialog:
Alert alert = waitForAlert(driver, Duration.ofSeconds(5));
String message = alert.getText();
alert.accept();

Use the constructor and imports supported by the Selenium release already used in your project. The expected condition waits until an alert is available and yields the alert handle. Selenium Java API: uses of Alert.

4. Accept, dismiss, or enter prompt text

Accept an alert or confirm

Alert alert = waitForAlert(driver, Duration.ofSeconds(5));
String message = alert.getText();
alert.accept(); // Acknowledge an alert or choose the affirmative confirm branch.

Dismiss a confirm

Alert alert = waitForAlert(driver, Duration.ofSeconds(5));
alert.dismiss(); // Choose the cancellation branch.

Submit a prompt response

Alert prompt = waitForAlert(driver, Duration.ofSeconds(5));
prompt.sendKeys("Ada");
prompt.accept();

To cancel a prompt without submitting a response, call dismiss(). Choose the operation that matches the branch your test is intended to cover. An alert has no meaningful cancel choice; dismissing one commonly has the same practical result as acknowledging it, but use accept() to express the intent clearly. Selenium Alert Java API.

5. Handle an HTML modal with WebElements

A modal implemented with HTML, CSS, and JavaScript remains part of the document. Its controls can usually be located just like other elements. Adapt selectors to the application’s markup:

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

WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(5));
wait.until(ExpectedConditions.visibilityOfElementLocated(By.cssSelector(".dialog")));
driver.findElement(By.cssSelector(".dialog input[name='name']")).sendKeys("Ada");
driver.findElement(By.cssSelector(".dialog button.confirm")).click();

Wait for a state that reflects readiness, such as visibility or clickability. A dialog may be visually present while its controls are still disabled or covered by an animation. In that case, wait for the control’s usable state and check for overlays or animations in the page implementation. Do not call switchTo().alert() for an HTML modal.

6. Deal with missing dialogs and beforeunload prompts

If no native dialog is active, driver.switchTo().alert() can throw NoAlertPresentException. When the application is expected to show one, wait for it and let a timeout fail the test with useful context. Catch the exception only when absence is an expected branch:

import org.openqa.selenium.NoAlertPresentException;
import org.openqa.selenium.WebDriver;

static boolean isAlertPresentNow(WebDriver driver) {
    try {
        driver.switchTo().alert();
        return true;
    } catch (NoAlertPresentException expectedWhenAbsent) {
        return false;
    }
}

For a required dialog, prefer the explicit wait rather than polling this helper or swallowing the exception. A timeout then points to the missing expected condition.

beforeunload behavior can vary with driver and browser configuration. Recent drivers automatically dismiss these prompts by default. If a test depends on handling one, inspect the configured unhandledPromptBehavior and the settings for the specific driver/browser pair rather than assuming a universal behavior. Selenium alert documentation.

7. Troubleshooting

Symptom	Likely cause	Fix
NoAlertPresentException	The dialog has not appeared, already closed, or is not a native JavaScript dialog.	Wait with alertIsPresent() after the triggering action. If it is HTML, locate its page elements instead.
Wait times out	The trigger did not run, the application did not show a dialog, or the wait is attached to the wrong driver/window.	Check that the triggering action succeeded and that the expected dialog belongs to the current browser session and window. Include the action and expected dialog in failure diagnostics.
Prompt response is missing	Text was not sent to the active prompt, or the prompt was dismissed rather than accepted.	Wait for the prompt, call sendKeys(value), then accept(). Verify the application’s resulting state.
Wrong confirm outcome	The test chose the opposite branch.	Use accept() for confirmation and dismiss() for cancellation; assert the corresponding application outcome.
switchTo().alert() cannot find a visible modal	The modal is HTML page content rather than a browser-native dialog.	Inspect the DOM and interact with its elements using locators and normal element waits.
Unexpected navigation prompt behavior	A beforeunload prompt is handled by the driver’s configured default.	Inspect unhandledPromptBehavior and the specific browser-driver configuration. Avoid relying on one default across all pairings.

8. Reliability, speed, and cost considerations

• Reliability: Synchronize on the alert-present condition when a native dialog is expected. Arbitrary sleeps can be too short on slow runs and waste time on fast ones. Let required-dialog timeouts fail clearly rather than treating a missing dialog as success.
• Test clarity: Assert the message when it matters, select the intended confirm branch explicitly, and verify the page outcome after the dialog closes.
• Performance: An explicit wait pauses only until the condition succeeds or its timeout expires. Keep the timeout aligned with the application’s expected response time; avoid repeated fixed delays.
• Cost: Selenium itself is an open source browser automation project, but a project’s actual run cost depends on its own browser, grid, and infrastructure setup. The cited Selenium API documentation does not establish pricing or performance benchmarks.

9. Or skip the browser setup

If the task is to obtain a page screenshot rather than exercise a dialog interaction, ScreenshotNeo is a website screenshot API and MCP server. Its API accepts one GET request with a URL and returns an image or PDF. See the ScreenshotNeo documentation for the API details.

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webp

import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"}, timeout=90)
open("shot.webp", "wb").write(r.content)

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);
if (!res.ok) throw new Error(`Screenshot request failed: ${res.status}`);
const image = Buffer.from(await res.arrayBuffer());
await import('node:fs/promises').then(fs => fs.writeFile('shot.webp', image));

Cookie banners, popups, and chat widgets are removed before the shot. Bot checks, blank pages, failed loads, timeouts, and cache hits are never billed; response headers report the page verdict and billing status. An MCP server lets AI agents use take_screenshot, get_page_info, and capture_pdf. The free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000. These captures do not replace Selenium when a test needs to accept a dialog or verify application behavior.

Sign up for 1,000 free screenshots a month, no card required.

10. FAQ

Can I read an alert’s text before closing it?

Yes. Get the alert handle, call getText(), then choose the appropriate action.

Can Selenium type into a native alert?

No response field is provided by an alert. A JavaScript prompt accepts text through sendKeys(); an HTML dialog’s input is a regular page element.

Should I catch NoAlertPresentException?

Only when no dialog is a valid expected outcome. If the test requires a dialog, wait for it and allow failure to report that it never appeared.

Does dismissing an alert cancel it?

Alerts do not offer a meaningful cancel choice. Use dismiss() to test cancellation for confirm and prompt dialogs.

Sources

• Selenium: JavaScript alerts, prompts and confirmations
• Selenium Java API: Alert
• Selenium Java API: WebDriver.TargetLocator
• Selenium Java API: Alert usage and expected condition
• Selenium alert fixture