What Is New In Selenium WebDriver 4?

What Is New In Selenium WebDriver 4

Are you a web developer looking for an easier way to test and verify your web applications? Well, you’re in luck! Selenium WebDriver 4 has recently been released with a slew of new features and capabilities, making it one of the most powerful tools in the market for automated testing. This blog post will look closely at what’s new in Selenium WebDriver 4 and how you can use it to make your web development process more efficient.

Difference between Selenium 3 and Selenium 4

Selenium 3 and Selenium 4 are web automation tools, but they differ significantly. In Selenium 3, the architecture was based on the client-server model, where each user request must pass through the server before the browser handles it. Whereas in Selenium 4, a new ‘DevTools’ architecture has been adopted, which shortens this process by directly sending commands from the user to the browser.

Selenium 4 provides updates such as improved command execution speed, support for service workers using DevTools API, integration with DevTools Protocol and W3C WebDriver protocol, support for mobile automation on Android and iOS devices, improved event logging system, and improved communication between server & clients. Examples include: For Android testing via Appium, Selenium 3 only had support for version 5.0 or lower, while in Selenium 4, newer versions of Android (9+) are supported; with regards to IE driver executors for Windows 10 users, only version 9+ is now supported in Selenium 4 compared to version 8 of IE in Selenium 3; Also EventFiringWebDriver functionality is available across all kinds of browsers except Safari on macOS in Selenium.

Selenium 4 Latest Features

1. W3C Standardization

Selenium 4 brings a significant change in the standardization of WebDriver API according to W3C standards. This will encourage compatibility across different software implementations and make requests and responses communicated via the protocol more straightforward, as no encoding or decoding is needed.

As most popular browsers such as Chrome, Safari, and IE already comply with W3C standards, integrating them seamlessly with Selenium 4 should be easy. For example, if you wanted to automate testing on the Firefox browser, the code written for Chrome would work without any modification.

Similarly, if you require automated tests in a specific platform like Linux or Android, the same code that worked elsewhere can be used again to test here with minimum modifications.

2. Selenium Grid Optimization

Selenium 4 brings several new and improved features, including an enhanced Selenium Grid feature with an improved UI, stability, and ease of installation. With these further improvements, we can simultaneously execute tests on multiple operating systems, browsers, and versions.

For example, if you want to test a website or web application on Windows 10 in Chrome 82 and Firefox 77 simultaneously, it is now possible to use Selenium Grid. Also, this means that users can now run their tests more efficiently by reducing debugging time for the same code running on different combinations of browsers and platforms. This further enables developers to deliver better quality work with less effort and at a quicker pace ensuring faster feedback from their user base.

Selenium 4 brings a revamped user interface and improved stability in Selenium Grid, allowing users to easily install and set up the hub-node connection. This is exemplified through features such as robust APIs, usage logs, and new command line options for troubleshooting.

Additionally, the Grid UI has improved flexibility and user-friendliness, as it now provides users with better insight into session capacity, runtime information, and other running sessions during a test.

Furthermore, users can benefit from advanced views that provide a global overview of all registered nodes in the Grid. As such, Selenium 4 has addressed many issues with earlier versions of Grid to bring about a more efficient testing experience.

3. Relative Locators

Relative Locators, also known as “Friendly Locators,” are a new feature in Selenium 4 that makes it easier to locate web elements by their relative position concerning other web elements. For example, we can use the Relative Locator’s ‘above’ and ‘below’ functions to identify a piece above or below another part on the page.

The Relative Locator also includes the ‘toLeftOf,’ ‘toRightOf,’ and ‘near’ functions, which allow us to specify the exact distance at which two elements must be for them to be recognized by Selenium. This makes it easy to find parts accurately when conventional locators such as IDs and classes are unavailable or unreliable.

Above: The ‘Above’ locator allows you to find an element positioned directly above another known element. To use this locator, you must first identify the available detail, then use the above() method to target the part you wish to interact with. An example of this might be finding an image that is placed directly above a text element on a webpage:

Below: The ‘Below’ locator works much like the ‘Above’ locator and allows you to find an element positioned directly below another known element. To use this locator, you must first identify the known part, then use the below() method to target the segment you wish to interact with. An example of this might be finding a form field that is placed directly below a text element on a webpage:

ToLeftOf: The ‘ToLeftOf’ locator allows you to find an element positioned directly to the left of another known component. To use this locator, you must first identify the known part, then use the toLeftOf() method to target the segment you wish to interact with. An example of this might be finding a checkbox that is placed directly left of a text element on a webpage:

ToRightOf: The ‘ToRightOf’ locator allows you to find an element positioned directly to the right of another known component. To use this locator, you must first identify the known part, then use the toRightOf() method to target the segment you wish to interact with. An example of this might be finding a text field that is placed directly right of a label on a webpage:

4. Multiple Windows & Tabs

With Selenium 4, we can work with multiple tabs or windows using the newWindow() method. To create a new Tab, we pass WindowType.TAB to the newWindow() method, and for creating a new window, we pass WindowType.WINDOW.

For example, driver.switchTo().newWindow(WindowType.TAB) opens a new tab on the same browser. In contrast, driver.switchTo().newWindow(WindowType.WINDOW) opens a new window of the same browser in a separate process enabling us to manage multiple sessions without having to create different WebDriver objects for each session simultaneously.

5. No support for Opera and PhantomJS

Selenium 4 has removed native support for Opera and PhantomJS, as the WebDriver implementations for these browsers are no longer under active development. If you are an Opera user, you can switch to Chrome as an alternative. Chrome offers a similar browser experience with the same level of support as Selenium. For example, it allows users to control their browsers through code and perform various tasks such as launching web pages, managing cookies, and taking screenshots.

Similarly, if you are a PhantomJS user, you can use either Chrome or Firefox in a headless mode. A headless browser is one without a graphical user interface operated from the command line. This makes it easier to automate web testing tasks. For instance, using Firefox in headless mode enables developers to launch websites and interact with them programmatically while not having to worry about rendering the page visually.

Overall, Selenium 4’s removal of native support for Opera and PhantomJS has opened up new opportunities for developers looking to automate their testing tasks. With the introduction of headless browsers such as Chrome or Firefox and the removal of native support for Opera and PhantomJS, Selenium 4 allows developers more control over their browsers while testing web applications.

6. Improved Selenium IDE

The latest version of Selenium IDE is a significant upgrade from its predecessors, introducing many new features and capabilities. This improved user experience is designed to make testing more accessible and efficient.

One of the key advantages of this version is the ability to export code for all official language bindings, including Java, Python, JavaScript, .Net, and Ruby. This allows developers to quickly create automated tests that can be used across multiple platforms. Additionally, it enables us to write code in a single language and execute it on various browsers.

The CLI runner (Selenium-side-runner) has also been introduced in this version which runs on NodeJs. This convenient feature allows us to perform playback and parallel execution on multiple browsers simultaneously. For example, we can program our tests to run concurrently in Chrome, Firefox, and Safari simultaneously by using Selenium Grid’s distributed test execution feature.

Selenium IDE’s latest version ushers in more advanced capabilities and features. It allows users to run tests on various browsers, such as Firefox, Google Chrome, and Internet Explorer. For example, users can now record their test case steps while using one browser, then play them back in another browser easily.

Furthermore, the reports generated by this new version provide detailed information such as the total number of test cases executed, execution time, number of test cases passed and failed. This makes it easier for testers to identify issues and address them accordingly. With the enhanced capabilities of Selenium IDE, users can easily create robust and reliable automated tests for their web applications.

7. WebElement Screenshot

Selenium 4 has improved the ability to capture screenshots of web pages. It provides a robust set of tools that allow users to take screenshots at different levels of UI.

For instance, when capturing a screenshot of an element, you can use the Selenium API method `getElementScreenshot()`, which returns an image file containing the screenshot of the web element. This is particularly useful for debugging as it allows users to quickly identify and fix issues with a component on the page.

Another example is capturing a screenshot of a section. This can be done using the Selenium API method `getSectionScreenshot().` This method takes in two arguments, start and end points, and then captures a screenshot of all elements within those two points on the page. This allows users to capture screenshots of specific areas without taking a full-page screenshot.

Finally, capturing full-page screenshots can be done using the Selenium API method’getScreenshotAs ()`. This method takes an argument of the desired screenshot format as a parameter and then returns the screenshot in that format. This allows users to capture full-page screenshots quickly and efficiently when needed.

In summary, Selenium 4 provides a robust suite of APIs to capture screenshots of web elements, sections, and entire pages. These features are great for debugging or taking snapshots of specific areas on a website. With Selenium 4, capturing screenshots quickly

8. Chrome DevTools

Selenium 4 has native support for the Chrome DevTools Protocol (CDP) through the “DevTools” interface. This allows users to access various Chrome development properties, including Application Cache, Fetch, Performance, Network, Profiler, Resource Timing, Security, and Target CDP domains.

With these new features of Selenium 4, developers can access data from Chrome Development sources and use it to automate web testing tasks. For example, developers could use the Fetch domain to simulate different HTTP requests for testing purposes, use the Performance domain to measure page loading times or evaluate how well a web application performs under load conditions. They can also take advantage of the Target domain to change the target URL of a test case as needed.

9. Monitoring

Selenium 4 brings many improvements to the Selenium Grid, making debugging and troubleshooting processes quicker and easier. With Selenium 4’s enhanced Logging and Request Tracing features, developers can quickly identify and isolate problems in their scripts.

For instance, when an error occurs during script execution, Selenium now provides detailed logging information that includes both the request sent to the browser and the response received. This enables developers to pinpoint any issues they encounter while writing scripts quickly.

Selenium also offers improved request-tracing capabilities that enable developers to trace requests across various components of their script. This helps them identify issues related to communication between different elements of their code.

10. Selenium documentation

Selenium 4 is officially released with comprehensive documentation for Selenium IDE, Selenium WebDriver, and Selenium Grid. This new release represents a significant milestone in the evolution of the open-source automation framework, providing users with improved features and capabilities.

Overall, the latest version of Selenium IDE provides a comprehensive suite of tools that make testing web applications a breeze. This ensures that application developers can access the best quality testing solutions.

What makes LambdaTest a perfect choice for developers To Run Selenium Scripts?

Expand your testing capabilities exponentially by running your Selenium scripts on our cloud of 3000+ desktop and mobile environments. Ensure security, scalability, and accelerated release cycles with LambdaTest’s cloud-based test execution platform.

With powerful features like real-time debugging and live interactive testing, you can rest assured that your Selenium tests are running reliably and efficiently. Make the most of your development and testing teams with LambdaTest’s cloud-based test execution platform. Rely on LambdaTest’s secure and scalable solution for your Selenium testing needs and accelerate your release cycles today!

1. End-to-end test execution logs

End-to-end test execution logs provide a comprehensive view of the process of executing automated tests, allowing for easier and more efficient debugging. By logging all steps taken during a Selenium test run, developers can quickly identify and debug potential issues that arise.

For example, when running an automated test in Selenium, the end-to-end test execution logs can provide a detailed view of the exact steps taken during each action. This includes logging the URL being tested, the commands sent to the browser and any errors that occur. Additionally, video logs can be generated to capture each step of a test run, providing developers with a visual representation of what happened during runtime.

Network logs are also available to help track down issues with page load times. By monitoring network requests and responses associated with each page load, developers can easily spot any bottlenecks or slowdowns that may impact their tests’ performance.

Finally, viewport screenshots can be captured at various points throughout a test run to provide additional insight into how certain elements appear on different browsers and devices. This is especially useful when troubleshooting cross-browser compatibility issues.

2. Geolocation Testing

Geolocation testing is integral to Selenium testing, as it ensures that your application or website works appropriately in different countries and regions. With LambdaTest’s out-of-the-box in-built geolocation testing feature, you can quickly test your application or website on 60+ country locations and regions. This eliminates the need for manual configuration of each region’s browser settings, enabling faster and more efficient testing.

For example, suppose you are developing a web application for customers in India and the United States. In that case, you can use LambdaTest’s geolocation testing to verify quickly how the application behaves when accessed from both countries. You can also use the feature to check how the website performs when accessed from multiple locations. This helps identify any problems that arise due to differences in latency or other factors.

LambdaTest’s out-of-the-box geolocation testing feature makes it easier to perform comprehensive Selenium testing and ensure the web application functions correctly in multiple locations. This helps developers quickly identify and address issues before the application goes into production.

3. Support for all languages & frameworks

The LambdaTest Selenium Grid is a powerful tool that supports all programming languages and robust test automation frameworks, making it an invaluable resource for those working with Selenium. Its versatility means testers can develop scripts in their preferred languages, such as Java or Python. The framework allows them to run tests quickly on different browsers and operating systems with minimal setup. This simplifies the process of automating cross-browser testing and eliminates the need to prepare test environments manually.

Another advantage of LambdaTest’s Selenium Grid is its compatibility with various popular test automation frameworks, including Appium, Jasmine, Cucumber, Nightwatch.js, and TestNG. This enables developers to use existing scripts for their tests, significantly reducing development time by eliminating the need to write new code from scratch. The framework also supports parallel testing, so multiple tests can be run simultaneously on different browsers and operating systems to reduce overall testing time.

4. Tunnel for local testing

Using LambdaTest’s enterprise-ready tunnel feature, Selenium users can quickly and easily test their locally hosted or privately hosted web apps and webpages for bugs and compatibility issues. This feature allows users to execute automated cross-browser testing in real time on 3000+ browsers and operating systems.

For example, if you have an application only available in your local development environment, the LambdaTest Tunnel allows you to run Selenium automation tests against it. You can also use it to test websites with restricted access, such as those behind a firewall or VPN.

With LambdaTest Tunnel, you can perform live interactive debugging of your locally hosted website using DevTools while running Selenium scripts. This will help you identify any issues quickly by providing a step-by-step view of what’s happening during testing.


Selenium WebDriver 4 has a lot to offer the community of automation testers. It provides an easier way to write and manage tests with improved performance and more reliable results. With its new features, such as support for W3C standard, headless execution, native events simulation, and cross-platform compatibility, Selenium WebDriver 4 is worth using for efficient automation testing.

This article gave you a good overview of the new features and capabilities of Selenium WebDriver 4. We would be glad to hear your thoughts on what you’ve read. What do you think of the new features? What would you like to see added next? Let us know in the comments!