When you start working with browser automation, one of the most common tasks is handling alerts, prompts, and confirmation dialogs. In this guide, you will learn how to handle Playwright Java alerts simply and effectively with clear examples. These dialogs often interrupt test flows, so knowing how to manage them is important for stable automation.
Alerts and dialogs are small pop-up messages that browsers display to interact with users. They can show information, ask for confirmation, or request input. Playwright Java provides a built-in dialog handling mechanism that listens for these events and allows you to accept, dismiss, or enter values programmatically. By using the dialog event listener, you can control every type of alert that appears during test execution.
- What Are Alerts and Dialogs in Playwright Java
- How to Handle Playwright Java Alerts Quickly
- Accept Alert in Playwright Java
- Dismiss Alert in Playwright Java
- Handle Confirm Dialog in Playwright Java
- Handle Prompt Dialog in Playwright Java
- Set Default Value in Dialog Prompt
- Global Dialog Handler in Playwright Java
- Automate Browser Popups and Other Dialogs
- Conclusion
What Are Alerts and Dialogs in Playwright Java
Browsers display different types of dialogs to communicate with users, and Playwright Java allows you to work with each one predictably. These dialogs interrupt normal page interaction until the user responds, which is why automated handling is required in tests.
Alert dialog:
An alert is a simple pop-up box that displays a message with a single OK button. It does not ask for input. Your only action is to accept it.
Confirm dialog:
A confirm dialog presents two choices, usually OK and Cancel. It is used when the website expects a yes or no type decision. In automation, you can accept or dismiss it based on your test requirements.
Prompt dialog:
A prompt dialog asks the user to enter text before proceeding. It includes a message, a text field, and options for OK and Cancel. Playwright Java allows you to accept the prompt with a custom value or dismiss it if no input is required.
By understanding the differences between these dialogs, you can choose the correct handling approach for each situation when automating interactions.
To learn how to interact with select elements, check out our detailed guide on handle dropdown in Playwright Java.
This tutorial shows how to select options, handle multiple selections, and automate dropdown interactions efficiently.
How to Handle Playwright Java Alerts Quickly
Below is the simplest working example that shows how to handle an alert in Playwright Java. This example listens for the dialog, prints its message, and accepts it.
page.onDialog(dialog -> {
System.out.println("Dialog message: " + dialog.message());
dialog.accept();
});
// Trigger the alert
page.evaluate("alert('Hello from alert')");Playwright Java listens for dialog events and allows you to respond immediately by accepting, dismissing, or entering text. Once the handler is registered, any alert that appears during the test can be controlled programmatically.
Accept Alert in Playwright Java
To accept a basic alert, you register a dialog listener and call the accept method when the alert appears. This is the most common scenario when working with browser popups. When the dialog event fires, Playwright captures the message and lets you respond instantly. This is how you naturally perform a playwright Java accept alert action.
page.onDialog(dialog -> {
if (dialog.type().equals("alert")) {
System.out.println("Alert message: " + dialog.message());
dialog.accept(); // Accept the alert
}
});
// Trigger an alert
page.evaluate("alert('Action required')");In this flow, Playwright Java detects the alert, prints its message for debugging, and accepts it automatically so your test can continue without interruption.
Dismiss Alert in Playwright Java
There are situations where you need to dismiss a dialog instead of accepting it. Dismissing is useful when the application expects a negative response or when you want to test how the system behaves after a cancel action. Playwright makes this simple by allowing you to check the dialog type and call dismiss when needed.
page.onDialog(dialog -> {
if (dialog.type().equals("alert")) {
System.out.println("Alert message: " + dialog.message());
dialog.dismiss(); // Dismiss the alert
}
});
// Trigger an alert
page.evaluate("alert('Do you want to cancel this action')");With this setup, the alert is detected and dismissed automatically, which helps you validate cancel scenarios and other negative paths in your test flow.
Handle Confirm Dialog in Playwright Java
A confirm dialog is used when a page expects a yes or no decision from the user. Playwright Java allows you to accept or reject the dialog based on what your test scenario requires. Working with a confirm dialog is similar to handling an alert, but you choose between accept and dismiss depending on the expected outcome.
Accept a confirmation dialog
page.onDialog(dialog -> {
if (dialog.type().equals("confirm")) {
System.out.println("Confirm message: " + dialog.message());
dialog.accept(); // Accept the confirm dialog
}
});
// Trigger confirm
page.evaluate("confirm('Do you want to continue')");Reject a confirmation dialog
page.onDialog(dialog -> {
if (dialog.type().equals("confirm")) {
System.out.println("Confirm message: " + dialog.message());
dialog.dismiss(); // Reject the confirm dialog
}
});
// Trigger confirm
page.evaluate("confirm('Are you sure you want to exit')");Using this approach, you can test both positive and negative paths of a confirm dialog naturally and ensure your application handles each decision correctly.
Handle Prompt Dialog in Playwright Java
A prompt dialog asks the user to enter text before clicking OK or Cancel. It is commonly used for username inputs, confirmation codes, or quick text-based actions. Playwright Java makes handling a prompt straightforward by allowing you to accept the dialog with a custom value or dismiss it if no input is needed.
To accept a prompt and provide a default value, you can use the accept method with a string argument. This value will be passed to the prompt input field automatically.
page.onDialog(dialog -> {
if (dialog.type().equals("prompt")) {
System.out.println("Prompt message: " + dialog.message());
dialog.accept("Sample value"); // Set default value and accept
}
});
// Trigger prompt
page.evaluate("prompt('Enter your name')");This approach helps you test any scenario where the page expects typed input from the user, ensuring smooth automation even when dialogs interrupt normal flow.
Set Default Value in Dialog Prompt
When a prompt dialog appears, the page expects some text input before continuing. Playwright Java allows you to set this value directly inside your dialog handler. This is useful when your test requires a predefined response. By accepting the dialog with a custom string, you can naturally perform a playwright java set dialog default value action without manual typing.
page.onDialog(dialog -> {
if (dialog.type().equals("prompt")) {
dialog.accept("Default text"); // Set default value
}
});
// Trigger prompt
page.evaluate("prompt('Provide input')");This example shows how Playwright Java automatically fills the prompt field with your specified text and accepts the dialog, ensuring smooth automation for any input-based pop-up.
Global Dialog Handler in Playwright Java
A global dialog handler is useful when your test interacts with multiple alerts, confirms, or prompts throughout the flow. Instead of registering a new listener each time, you can set one dialog handler that reacts to every popup. This makes your automation stable and predictable. The event listener method used for this purpose is page.onDialog, which is a core part of how the playwright dialog handler java approach works.
Download Sample HTML File
Use the sample page below to practice alert, confirm, prompt, and popup handling in Playwright Java.
Download dialogs-demo.html
Example:
import com.microsoft.playwright.*;
public class DialogHandlerExample {
public static void main(String[] args) {
try (Playwright playwright = Playwright.create()) {
Browser browser = playwright.chromium().launch(new BrowserType.LaunchOptions()
.setHeadless(false));
BrowserContext context = browser.newContext();
Page page = context.newPage();
// Global dialog handler
page.onDialog(dialog -> {
System.out.println("Dialog type: " + dialog.type());
System.out.println("Dialog message: " + dialog.message());
switch (dialog.type()) {
case "alert":
dialog.accept();
break;
case "confirm":
dialog.accept(); // or dialog.dismiss()
break;
case "prompt":
dialog.accept("Auto filled value");
break;
default:
dialog.dismiss();
}
});
// Load local HTML file
page.navigate("file:///D:/dialogs-demo.html");
// 1. Click "Show Alert"
page.click("text=Show Alert");
// 2. Click "Show Confirm"
page.click("text=Show Confirm");
// 3. Click "Show Prompt"
page.click("text=Show Me Prompt");
// Pause to visually confirm before closing
page.waitForTimeout(2000);
}
}
} With this global handler in place, every dialog that appears during execution is processed automatically, helping you avoid test interruptions and creating a clean, reusable structure for handling browser dialogs.
Automate Browser Popups and Other Dialogs
Along with alerts, confirm boxes, and prompts, you may also encounter other types of browser pop-ups during automation. These pop-ups interrupt the test flow in a similar way, which means they also need a proper handler. When you handle popups in Playwright Java, you rely on the same dialog listening mechanism because Playwright treats browser dialogs as dialog events that must be accepted or dismissed before the page can continue.
Popups and dialogs both block interaction until a user action is taken. By setting up a dialog handler with page.onDialog, you ensure that any unexpected pop-up or dialog is automatically processed. This prevents your test from getting stuck and keeps your automation stable.
With a single global or targeted handler in place, Playwright Java can respond to browser dialogs, confirmation boxes, prompts, and other pop-up messages consistently, allowing your scripts to run smoothly from start to finish.
Conclusion
In this guide, you learned how to handle Playwright Java alerts effectively, covering alerts, confirm dialogs, and prompt dialogs. We explored how to accept, dismiss, and provide default values, as well as how to set up a global dialog handler to manage multiple popups in a single test flow. By applying these techniques to real world scenarios like login confirmations, delete confirmations, form submissions, and API mock tests, you can create stable and reliable browser automation scripts.
With these strategies, handling browser dialogs in Playwright Java becomes straightforward, ensuring your tests run smoothly without interruptions.
