How to Handle Multiple Tabs in Playwright Java

By AravindPlaywright Java
Illustration showing switching between multiple tabs in Playwright Java automation testing

Last updated on November 8th, 2025 at 11:27 am

When automating web applications, it is quite common to work with scenarios that involve multiple browser tabs. In such cases, testers need a reliable way to manage and interact with each open tab during test execution. This is where Handle Multiple Tabs in Playwright Java becomes an essential part of browser automation.

Playwright Java provides powerful APIs that allow you to open new tabs, switch between them, close specific tabs, and retrieve all open tabs from the browser context. These capabilities help in building end-to-end test scenarios, such as navigating between login and registration pages, validating links that open in new tabs, or checking form submissions across multiple pages.

By mastering tab management in Playwright Java, testers can create more realistic and efficient automation scripts that closely mimic real user behavior.

Multiple browser tabs opened for login, register, and contact pages in Playwright Java test
Example showing multiple tabs opened during Playwright Java automation test

What Are Tabs and Pages in Playwright Java?

In Playwright Java, every browser tab is represented as a Page object. When a user opens a new tab in the browser, Playwright automatically creates a new Page instance for that tab. This means you can easily interact with elements, perform actions, and verify page content on each tab individually using the Page interface.

Diagram showing Playwright Java browser context containing multiple page instances
Playwright Java browser context manages multiple pages or tabs

All these pages or tabs exist inside a browser context. A browser context acts like a container that holds one or more pages. You can think of it as a separate browser session where multiple tabs can run independently without affecting each other. This design makes Playwright Java page context very powerful, especially for managing multiple tabs or running tests in parallel.

When you work with Playwright Java browser context multiple pages, it allows you to simulate real-world user behavior—such as logging in on one tab and verifying results on another, or opening external links that launch in new tabs. Each tab, represented by a Page instance, can be accessed, switched, or closed as needed within the same browser context.

How to Handle Multiple Tabs in Playwright Java

Before we start handling multiple tabs in Playwright, let’s first prepare our local setup. You can download the practice HTML files (login.html, register.html, and contactus.html) from the link provided below and save them in the same folder on your local machine.

Download login.html

Download register.html

Download contactus.html

Login page HTML showing register and contact links opening new tabs in Playwright Java
HTML example used to demonstrate opening new tabs in Playwright Java

Guidelines before running the example:

  1. Download all three HTML files from the Google Drive link.
  2. Save them in a single folder, for example: D:\playwright-multiple-tabs\
  3. Make sure the file paths remain correct because Playwright will access these pages using local file URLs, such as: file:///D:/playwright-multiple-tabs/login.html
  4. Once saved, you can use these files to practice tab operations like opening new tabs, switching between them, closing tabs, and retrieving all open tabs.

Example: Handle Multiple Tabs in Playwright Java

Below is a complete step-by-step example showing how to handle multiple tabs in Playwright Java. This includes how to open a Playwright Java new tab, switch tabs, get all tabs, and close tabs.

 package com.example.test;

import com.microsoft.playwright.*;
import java.util.List;

public class HandleMultipleTabsExample {
	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();

			// Step 1: Open the local login page
			page.navigate("file:///D:/playwright-multiple-tabs/login.html");

			// Step 2: Click on 'Register Here' link and wait for new tab
			Page registerTab = context.waitForPage(() -> {
				page.locator("#registerLink").click();
			});
			registerTab.waitForLoadState();
			System.out.println("New tab opened: " + registerTab.title());

			// Step 3: Interact with elements in register tab
			registerTab.locator("#fullname").fill("John Doe");
			registerTab.locator("#email").fill("john@example.com");
			registerTab.locator("#password").fill("password123");
			registerTab.locator("#registerBtn").click();

			// Step 4: Switch back to main login tab
			page.bringToFront();

			// Step 5: Click 'Contact Us' link and wait for contact tab
			Page contactTab = context.waitForPage(() -> {
				page.locator("#contactLink").click();
			});
			contactTab.waitForLoadState();
			System.out.println("Another tab opened: " + contactTab.title());

			// Step 6: Interact with contact page elements
			contactTab.locator("#name").fill("John Tester");
			contactTab.locator("#message").fill("This is a test message!");
			contactTab.locator("#sendMessage").click();

			// Step 7: Get list of all open tabs (Playwright Java get all tabs)
			List<Page> allTabs = context.pages();
			System.out.println("Total open tabs: " + allTabs.size());
			for (Page p : allTabs) {
				System.out.println("Tab title: " + p.title());
			}

			// Step 8: Close one specific tab (Playwright Java close tab)
			contactTab.close();
			System.out.println("Closed contactus.html tab");

			// Step 9: Verify remaining open tabs
			System.out.println("Tabs remaining after close: " + context.pages().size());

			browser.close();
		}
	}
}

In this example, we:

  • Opened a Playwright Java new tab by clicking a link.
  • Performed a Playwright Java switch tabs operation to move between pages.
  • Used context.pages() to Playwright Java get all tabs.
  • Closed a specific tab using page.close() to demonstrate Playwright Java close tab handling.

This step-by-step approach makes tab management simple, effective, and close to real-world test scenarios.

Example: Open and Switch Between Tabs

In this example, you will learn how to open a new tab using context.newPage() and switch between different tabs using Playwright Java. This helps in mastering Playwright Java switch tabs and understanding effective Playwright Java tab management techniques.

Let’s look at a simple example:

package com.example.test;

import com.microsoft.playwright.*;
import java.util.List;

public class SwitchBetweenTabsExample {
	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();

			// Step 1: Open the first tab (login page)
			Page loginPage = context.newPage();
			loginPage.navigate("file:///D:/playwright-multiple-tabs/login.html");
			System.out.println("Opened first tab: " + loginPage.title());

			// Step 2: Open a new tab using context.newPage()
			Page registerPage = context.newPage();
			registerPage.navigate("file:///D:/playwright-multiple-tabs/register.html");
			System.out.println("Opened second tab: " + registerPage.title());

			// Step 3: Get a list of all open tabs
			List<Page> allTabs = context.pages();
			System.out.println("Total open tabs: " + allTabs.size());

			// Step 4: Switch between tabs using the list of pages
			System.out.println("Switching to first tab (Login Page)...");
			allTabs.get(0).bringToFront(); // Switch to the first tab
			System.out.println("Now active tab: " + allTabs.get(0).title());

			System.out.println("Switching to second tab (Register Page)...");
			allTabs.get(1).bringToFront(); // Switch to the second tab
			System.out.println("Now active tab: " + allTabs.get(1).title());

			// Step 5: Perform tab management actions
			registerPage.locator("#fullname").fill("Alice Tester");
			registerPage.locator("#email").fill("alice@example.com");
			registerPage.locator("#password").fill("mypassword");
			registerPage.locator("#registerBtn").click();

			// Step 6: Close the browser
			browser.close();
		}
	}
}

Explanation of the Steps

  1. Create the first tab:
    A new tab is created with context.newPage() and navigates to the local login.html file.
  2. Open another tab:
    Another new tab is opened using context.newPage() and loads register.html.
  3. Retrieve all open tabs:
    The method context.pages() returns a list of all tabs currently open in the browser context.
  4. Switch between tabs:
    The bringToFront() method is used to activate a specific tab. This demonstrates Playwright Java switch tabs effectively.
  5. Tab management and interaction:
    You can perform operations like filling forms or clicking buttons on any tab that is active. This showcases Playwright Java tab management in action.

By practicing this example, you’ll learn how to easily switch between multiple browser tabs and manage them efficiently within the same Playwright session.

Example: Get All Tabs in Browser Context

In Playwright Java, you can easily retrieve all currently open tabs using the context.pages() method. This is a powerful feature that allows you to manage and interact with every active tab in your test session. Understanding how Playwright Java get all tabs works helps in verifying and controlling multiple open pages efficiently.

Here’s a practical example:

package com.example.test;

import com.microsoft.playwright.*;
import java.util.List;

public class GetAllTabsExample {
	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();

			// Step 1: Open main login page
			Page loginPage = context.newPage();
			loginPage.navigate("file:///D:/playwright-multiple-tabs/login.html");
			System.out.println("Opened: " + loginPage.title());

			// Step 2: Open two more tabs manually using newPage()
			Page registerPage = context.newPage();
			registerPage.navigate("file:///D:/playwright-multiple-tabs/register.html");

			Page contactPage = context.newPage();
			contactPage.navigate("file:///D:/playwright-multiple-tabs/contactus.html");

			// Step 3: Get all open tabs in the current browser context
			List<Page> allTabs = context.pages();
			System.out.println("Total open tabs: " + allTabs.size());

			// Step 4: Print titles of all tabs
			for (Page p : allTabs) {
				System.out.println("Tab Title: " + p.title());
			}

			// Step 5: Example of switching to each tab and verifying content
			for (Page p : allTabs) {
				p.bringToFront();
				System.out.println("Now active tab: " + p.title());
			}

			browser.close();
		}
	}
}

How It Works

  • context.pages() returns a list of Page objects, where each Page represents an open browser tab within that browser context.
  • You can loop through this list to get titles, switch tabs, or perform interactions on each tab.
  • Since each tab operates independently, you can run checks or validations across all open pages.
Console output showing total number of open tabs retrieved using Playwright Java
Playwright Java get all tabs example showing tab count in console

Real-World Scenarios

  • Validating linked pages: When testing links that open in new tabs, you can ensure each tab displays the expected content.
  • Parallel content checks: Retrieve all open tabs and verify that user information or messages appear consistently across multiple pages.
  • Tab cleanup: After running complex test flows, you can loop through context.pages() to close unnecessary tabs and keep the session clean.

This approach gives you full control over browser tab handling, making Playwright Java get all tabs a valuable tool for multi-tab testing scenarios.

Example: Close a Specific Tab

In Playwright Java, you can close individual tabs or all open tabs programmatically using the close() method. This is useful when you want to clean up unused pages after completing a test. Understanding how Playwright Java’s close tab works ensures smoother test execution and prevents resource leaks.

Here’s an example demonstrating how to close a specific tab as well as all tabs in a browser context:

import com.microsoft.playwright.*;
import java.util.List;

public class CloseSpecificTabExample {
    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();

            // Step 1: Open multiple tabs
            Page loginPage = context.newPage();
            loginPage.navigate("file:///D:/playwright-multiple-tabs/login.html");

            Page registerPage = context.newPage();
            registerPage.navigate("file:///D:/playwright-multiple-tabs/register.html");

            Page contactPage = context.newPage();
            contactPage.navigate("file:///D:/playwright-multiple-tabs/contactus.html");

            // Step 2: Print all open tabs
            List<Page> allTabs = context.pages();
            System.out.println("Open tabs count: " + allTabs.size());

            // Step 3: Close a specific tab (register.html)
            System.out.println("Closing register page tab...");
            registerPage.close();
            System.out.println("Register page closed successfully.");

            // Step 4: Verify remaining open tabs
            allTabs = context.pages();
            System.out.println("Remaining open tabs: " + allTabs.size());

            // Step 5: Close all remaining tabs safely
            for (Page tab : allTabs) {
                tab.close();
            }
            System.out.println("All tabs closed successfully.");

            browser.close();
        }
    }
}

Explanation

  • Each open tab is represented by a Page object.
  • Calling page.close() closes only that specific tab, allowing other tabs to remain active.
  • You can loop through context.pages() to close all tabs at once if needed.

Tip

It is a good practice to close unused tabs after each test execution. This helps free memory, prevents unwanted test interference, and ensures that your Playwright session remains clean and predictable.

Using Playwright Java to close tabs effectively helps maintain efficient resource management in your automated test suites.

Using Browser Context for Multiple Pages

In Playwright Java, a BrowserContext acts like an isolated browser session. Each context can hold multiple tabs (pages) that don’t share cookies, cache, or session data with other contexts. This isolation helps simulate different users or environments within the same test run.

Each tab in a context represents a Page instance. Therefore, when you work with multiple tabs, you’re actually managing multiple Page objects within one browser context. But when you create multiple browser contexts, you can test multiple independent sessions in parallel.

This concept is central to Playwright Java page context and Playwright Java browser context multiple pages testing.

Here’s a simple example demonstrating how to use multiple browser contexts in Playwright Java:

package com.example.test;

import com.microsoft.playwright.*;

public class MultipleBrowserContextsExample {
	public static void main(String[] args) {
		try (Playwright playwright = Playwright.create()) {
			Browser browser = playwright.chromium().launch(new BrowserType.LaunchOptions().setHeadless(false));

			// Create first browser context and open a page
			BrowserContext context1 = browser.newContext();
			Page page1 = context1.newPage();
			page1.navigate("https://playwright.dev");
			System.out.println("Context 1 - Page title: " + page1.title());

			// Create second browser context and open another page
			BrowserContext context2 = browser.newContext();
			Page page2 = context2.newPage();
			page2.navigate("https://playwright.dev/docs/intro");
			System.out.println("Context 2 - Page title: " + page2.title());

			// Perform independent actions in each context
			System.out.println("Each context runs independently with its own session data.");

			// Close both contexts
			context1.close();
			context2.close();
		}
	}
}

Explanation:

  • browser.newContext() creates a new isolated environment.
  • Each context can have multiple tabs (pages), but they won’t interfere with each other.
  • This allows parallel testing or session-based isolation for better test reliability.

Tip: Use separate contexts when testing login scenarios for multiple users to prevent session conflicts.

This approach makes Playwright Java ideal for scalable, parallel, and independent page context testing.

What’s Next

Now that you have learned how to handle multiple tabs in Playwright Java, the next step is to understand how to manage browser contexts and sessions effectively.

Read this detailed guide:
Handle Browser Contexts and Sessions in Playwright Java

This article explains how to work with multiple browser contexts, maintain isolated sessions, and improve the efficiency of your Playwright test automation.

10. Conclusion

Handling multiple tabs in Playwright Java is an essential skill for modern browser automation. It allows testers to interact with different pages, switch between them, validate content, and close them programmatically, all within the same test flow.

By mastering Handle Multiple Tabs in Playwright Java, you can simulate real user interactions across multiple pages, such as registration, login, and dashboard navigation. These techniques not only make your tests more realistic but also improve reliability and scalability in complex web applications.

Start applying these Playwright Java tab management methods to create efficient, maintainable, and high-quality automated test scripts.

author avatar
Aravind QA Automation Engineer & Technical Blogger
Aravind is a QA Automation Engineer and technical blogger specializing in Playwright, Selenium, and AI in software testing. He shares practical tutorials to help QA professionals improve their automation skills.
See Full Bio
Selenium Testing Playwright automation Software quality assurance Codeless test automation JMeter performance testing Appium mobile automation Excel for test data management End-to-end testing
social network icon social network icon
Stay Updated with New Articles
Get the latest tutorials and insights delivered to your inbox.
By subscribing, you agree to our privacy policy and terms of service.

You might also like:

Handle Text Box in Playwright Java

How to Handle Playwright Java Text Box With Example

How to double-click in Playwright Java tutorial

How to Perform Double-Click in Playwright Java

Click on Element in Playwright Java Tutorial

How to Click on Element in Playwright Java

Leave a Reply

Your email address will not be published. Required fields are marked *