Executing JavaScript in Selenium means running JavaScript code directly inside a web browser through Selenium WebDriver. Selenium provides the JavascriptExecutor interface to execute JavaScript statements, inspect the Document Object Model (DOM), scroll web pages, retrieve browser information, and perform specialized browser-side operations.
JavaScript is commonly used to create interactive web applications. When testing these applications, automation testers sometimes need to inspect browser-side information or perform operations that are not conveniently available through standard WebDriver methods. JavascriptExecutor provides this additional capability.
Course Links: Selenium Training Course | Register for Course Demo
JavaScript is a programming language used to add dynamic and interactive functionality to web pages. It can interact with HTML elements, CSS styles, browser APIs, events, and the DOM.
Examples of JavaScript functionality include form validation, dropdown menus, dynamic content, animations, popups, and interactive buttons.
Executing JavaScript in Selenium means sending JavaScript code from a Java automation program to the browser for execution. Selenium receives the result when the script returns a value.
JavascriptExecutor js = (JavascriptExecutor) driver;
String title = (String) js.executeScript("return document.title;");
System.out.println(title);
JavascriptExecutor is an interface provided by Selenium WebDriver that allows Java programs to execute JavaScript in the browser context.
It is useful for browser-side inspection, scrolling, retrieving DOM properties, reading page information, and performing specialized JavaScript operations.
import org.openqa.selenium.JavascriptExecutor;WebDriver driver = new ChromeDriver();
JavascriptExecutor js = (JavascriptExecutor) driver;
The driver is cast to JavascriptExecutor so that the Java program can execute browser-side JavaScript.
Java Selenium Program
|
v
JavascriptExecutor Interface
|
v
executeScript()
|
v
Browser JavaScript Engine
|
v
DOM or Browser Operation
|
v
Result Returned to Java
The executeScript() method executes JavaScript synchronously in the current browsing context.
Object result = js.executeScript("return document.title;");The returned value is represented as an Object and can be converted into an appropriate Java type.
JavascriptExecutor js = (JavascriptExecutor) driver;
String title = (String) js.executeScript("return document.title;");
System.out.println("Page Title: " + title);
String url = (String) js.executeScript("return window.location.href;");
System.out.println("Current URL: " + url);
String domain = (String) js.executeScript("return document.domain;");
System.out.println("Domain: " + domain);
Long width = (Long) js.executeScript("return window.innerWidth;");
System.out.println("Window Width: " + width);
Long height = (Long) js.executeScript("return window.innerHeight;");
System.out.println("Window Height: " + height);
Long pageHeight = (Long) js.executeScript(
"return document.documentElement.scrollHeight;"
);
System.out.println("Page Height: " + pageHeight);
String state = (String) js.executeScript("return document.readyState;");
System.out.println("Ready State: " + state);
Common document.readyState values are:
Boolean complete = (Boolean) js.executeScript(
"return document.readyState === 'complete';"
);
System.out.println("Document Complete: " + complete);
This checks the document loading state. It does not guarantee that every asynchronous application request or dynamic component has finished.
js.executeScript("window.scrollBy(0, 500);");The page scrolls down by approximately 500 pixels.
js.executeScript("window.scrollBy(0, -500);");js.executeScript("window.scrollTo(0, 0);");js.executeScript(
"window.scrollTo(0, document.documentElement.scrollHeight);"
);
js.executeScript("window.scrollBy(500, 0);");The scrollIntoView() method moves an element into the visible portion of the page.
WebElement element = driver.findElement(By.id("submit"));
js.executeScript(
"arguments[0].scrollIntoView(true);",
element
);
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
element
);
Centering the element can help when a sticky header or footer might cover the target after scrolling.
js.executeScript(
"arguments[0].scrollIntoView({behavior:'smooth', block:'center'});",
element
);
When a WebElement is passed to executeScript(), it can be accessed inside JavaScript using arguments[0]. Additional arguments can be accessed using arguments[1], arguments[2], and so on.
js.executeScript(
"arguments[0].style.border='2px solid red';",
element
);
JavaScript can invoke the DOM click() method on an element.
WebElement button = driver.findElement(By.id("submit"));
js.executeScript(
"arguments[0].click();",
button
);
Important: Prefer element.click() for normal user interactions. JavaScript click does not reproduce every aspect of a real pointer interaction and can bypass conditions that a normal Selenium click would expose.
| Normal Selenium Click | JavaScript Click |
|---|---|
| Uses WebDriver interaction behavior. | Invokes the DOM click method. |
| Suitable for normal user-like testing. | Useful for specialized browser-side operations. |
| Can reveal overlays and interaction problems. | May trigger an event without normal pointer interaction. |
| Preferred for routine automation. | Should be used when justified. |
WebElement input = driver.findElement(By.id("username"));
js.executeScript(
"arguments[0].value='admin';",
input
);
Directly setting value changes the DOM property but may not trigger the input and change events expected by a web application. Use sendKeys() for ordinary user-like text entry.
WebElement input = driver.findElement(By.id("username"));
input.clear();
input.sendKeys("admin");
String text = (String) js.executeScript(
"return arguments[0].textContent;",
element
);
System.out.println(text);
| Property | Description |
|---|---|
| textContent | Returns the text content in the DOM, including text that may not be visibly rendered. |
| innerText | Returns rendered text and generally reflects visibility and layout. |
String value = (String) js.executeScript(
"return arguments[0].getAttribute('value');",
element
);
String href = (String) js.executeScript(
"return arguments[0].getAttribute('href');",
element
);
String id = (String) js.executeScript(
"return arguments[0].id;",
element
);
String className = (String) js.executeScript(
"return arguments[0].className;",
element
);
String value = (String) js.executeScript(
"return arguments[0].value;",
input
);
String tagName = (String) js.executeScript(
"return arguments[0].tagName;",
element
);
Long width = (Long) js.executeScript(
"return arguments[0].offsetWidth;",
element
);
Long height = (Long) js.executeScript(
"return arguments[0].offsetHeight;",
element
);
Object rect = js.executeScript(
"return arguments[0].getBoundingClientRect().toJSON();",
element
);
System.out.println(rect);
Boolean disabled = (Boolean) js.executeScript(
"return arguments[0].disabled;",
element
);
Boolean checked = (Boolean) js.executeScript(
"return arguments[0].checked;",
checkbox
);
Highlighting is helpful during debugging because it makes an element easier to identify visually.
js.executeScript(
"arguments[0].style.border='3px solid red';",
element
);
js.executeScript(
"arguments[0].style.backgroundColor='yellow';",
element
);
js.executeScript(
"arguments[0].style.border='3px solid red';" +
"arguments[0].style.backgroundColor='yellow';",
element
);
js.executeScript(
"arguments[0].style.border='';" +
"arguments[0].style.backgroundColor='';",
element
);
String color = (String) js.executeScript(
"return window.getComputedStyle(arguments[0]).color;",
element
);
String background = (String) js.executeScript(
"return window.getComputedStyle(arguments[0]).backgroundColor;",
element
);
WebElement element = (WebElement) js.executeScript(
"return document.getElementById('username');"
);
WebElement element = (WebElement) js.executeScript(
"return document.querySelector('#username');"
);
Long count = (Long) js.executeScript(
"return document.querySelectorAll('input').length;"
);
System.out.println("Input Count: " + count);
Boolean exists = (Boolean) js.executeScript(
"return document.querySelector('#username') !== null;"
);
Long scrollY = (Long) js.executeScript("return window.scrollY;");
Long scrollX = (Long) js.executeScript("return window.scrollX;");
js.executeScript(
"arguments[0].value = arguments[1];",
input,
"automation"
);
js.executeScript(
"window.scrollBy(arguments[0], arguments[1]);",
0,
500
);
js.executeScript(
"arguments[0].checked = arguments[1];",
checkbox,
true
);
The executeAsyncScript() method executes JavaScript that completes asynchronously. Selenium waits for the callback supplied to the script, subject to the configured script timeout.
Object result = js.executeAsyncScript(
"var callback = arguments[arguments.length - 1];" +
"setTimeout(function() {" +
"callback('Completed');" +
"}, 1000);"
);
System.out.println(result);
| executeScript() | executeAsyncScript() |
|---|---|
| Executes synchronous JavaScript. | Supports asynchronous JavaScript using a callback. |
| Returns after script execution. | Returns after the callback completes. |
| Suitable for immediate DOM operations. | Suitable for callback-based asynchronous work. |
driver.manage().timeouts().scriptTimeout(Duration.ofSeconds(10));WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(20)
);
wait.until(d ->
"complete".equals(
((JavascriptExecutor) d).executeScript(
"return document.readyState;"
)
)
);
This checks document readiness only. For dynamically loaded elements, wait for the relevant application condition as well.
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement button = wait.until(
ExpectedConditions.visibilityOfElementLocated(By.id("submit"))
);
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
button
);
button.click();
To work with elements inside an iframe, switch to the correct frame before locating or interacting with those elements.
driver.switchTo().frame("paymentFrame");
WebElement field = driver.findElement(By.id("card"));
field.sendKeys("1234");
driver.switchTo().defaultContent();
Switch to the correct browser window or tab before executing JavaScript in its document context.
String originalWindow = driver.getWindowHandle();
for (String handle : driver.getWindowHandles()) {
if (!handle.equals(originalWindow)) {
driver.switchTo().window(handle);
break;
}
}
String value = (String) js.executeScript(
"return window.localStorage.getItem('username');"
);
js.executeScript(
"window.localStorage.setItem('username', 'admin');"
);
js.executeScript(
"window.localStorage.removeItem('username');"
);
js.executeScript("window.localStorage.clear();");String value = (String) js.executeScript(
"return window.sessionStorage.getItem('sessionId');"
);
js.executeScript("window.sessionStorage.clear();");String cookies = (String) js.executeScript(
"return document.cookie;"
);
JavaScript's document.cookie does not expose every cookie in all circumstances, such as cookies marked HttpOnly. For standard cookie operations, Selenium's cookie API is generally preferable.
Set<Cookie> cookies = driver.manage().getCookies();
driver.manage().addCookie(
new Cookie("testCookie", "testValue")
);
Some modern web components use Shadow DOM to encapsulate their internal markup. An open shadow root can be accessed through JavaScript when needed.
WebElement host = driver.findElement(By.cssSelector("#shadow-host"));
WebElement shadowElement = (WebElement) js.executeScript(
"return arguments[0].shadowRoot.querySelector('#username');",
host
);
Open shadow roots expose the shadowRoot property. Closed shadow roots restrict ordinary direct access through this property. Selenium's supported ShadowRoot APIs may be appropriate for working with accessible shadow DOM structures.
driver.get("https://example.com");For normal navigation, driver.get() is preferred over changing window.location through JavaScript.
driver.navigate().refresh();Although JavaScript can invoke location.reload(), Selenium's navigation API is generally clearer for standard browser navigation.
Use Selenium's Alert interface to handle JavaScript alerts, confirmations, and prompts.
Alert alert = driver.switchTo().alert();
alert.accept();
For standard HTML select elements, use Selenium's Select class instead of manipulating the selection directly through JavaScript.
Select select = new Select(
driver.findElement(By.id("country"))
);
select.selectByVisibleText("India");
Use Selenium's keyboard APIs or Actions class when testing keyboard behavior.
Actions actions = new Actions(driver);
actions.sendKeys(Keys.ENTER).perform();
For mouse hover, drag and drop, and click-and-hold interactions, Selenium's Actions class is normally the preferred API.
Actions actions = new Actions(driver);
actions.moveToElement(element).perform();
For a standard file input, send the file path directly to the element.
WebElement upload = driver.findElement(
By.cssSelector("input[type='file']")
);
upload.sendKeys("C:\\files\\test.pdf");
JavaScript can help inspect or highlight an element before a screenshot is taken. Selenium's TakesScreenshot interface is used to capture screenshots.
File screenshot = ((TakesScreenshot) driver)
.getScreenshotAs(OutputType.FILE);
Modern applications may update their DOM asynchronously. JavascriptExecutor can inspect the browser state, but it does not automatically wait for an application request to finish.
| Explicit Wait | JavaScriptExecutor |
|---|---|
| Waits for a specified condition. | Executes JavaScript in the browser. |
| Helps synchronize dynamic elements. | Helps inspect or perform browser-side operations. |
| Uses ExpectedConditions or custom conditions. | Uses JavaScript statements and arguments. |
| Preferred for synchronization. | Not a general replacement for waits. |
Lazy-loaded content may appear only after scrolling. Scroll the page and then wait for the expected content to appear.
js.executeScript(
"window.scrollTo(0, document.documentElement.scrollHeight);"
);
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.cssSelector(".lazy-content")
)
);
For infinite-scroll pages, repeatedly scroll and wait for a meaningful change, such as additional results appearing. Avoid relying on fixed sleeps when a reliable condition can be checked.
JavascriptException may occur when the browser cannot execute the supplied script. Common causes include invalid JavaScript syntax, invalid operations, and assumptions about unavailable elements or properties.
A stale element reference can occur when the DOM changes after a WebElement has been located. Locate the element again after the relevant page update when necessary.
This exception may indicate that an element exists but cannot be interacted with in its current state. Check visibility, enabled state, overlays, synchronization, and browsing context.
This exception can occur when another element covers the target or intercepts the click. Investigate the overlay, page state, scrolling, and timing before considering an alternative.
Replacing every Selenium click with JavaScript can hide real application problems. Prefer normal WebDriver interaction for routine user actions.
JavaScript execution does not guarantee that a dynamic page has finished loading. Use explicit waits for the relevant element or application state.
Directly assigning an input value may bypass the events expected by a JavaScript framework. Use sendKeys() for standard form automation unless direct DOM manipulation is specifically required.
Always verify that Selenium is operating in the correct frame and window before executing JavaScript against a page.
Removing disabled attributes or changing application state through JavaScript can make a test pass without validating the behavior experienced by users. Avoid these operations unless they are part of a clearly defined test requirement.
import org.openqa.selenium.JavascriptExecutor;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
public class JavaScriptUtil {
private final JavascriptExecutor js;
public JavaScriptUtil(WebDriver driver) {
this.js = (JavascriptExecutor) driver;
}
public String getPageTitle() {
return (String) js.executeScript(
"return document.title;"
);
}
public String getCurrentUrl() {
return (String) js.executeScript(
"return window.location.href;"
);
}
public void scrollToElement(WebElement element) {
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
element
);
}
public void scrollToTop() {
js.executeScript("window.scrollTo(0, 0);");
}
public void scrollToBottom() {
js.executeScript(
"window.scrollTo(0, document.documentElement.scrollHeight);"
);
}
public void highlightElement(WebElement element) {
js.executeScript(
"arguments[0].style.border='3px solid red';",
element
);
}
public String getReadyState() {
return (String) js.executeScript(
"return document.readyState;"
);
}
}
In the Page Object Model (POM), page-specific JavaScript operations can be kept inside page classes or shared utility classes. This avoids duplicating JavaScript snippets across test cases.
public class LoginPage {
private final WebDriver driver;
private final JavascriptExecutor js;
private final By username = By.id("username");
private final By loginButton = By.id("login");
public LoginPage(WebDriver driver) {
this.driver = driver;
this.js = (JavascriptExecutor) driver;
}
public void enterUsername(String user) {
driver.findElement(username).sendKeys(user);
}
public void clickLogin() {
WebElement button = driver.findElement(loginButton);
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
button
);
button.click();
}
}
@Test
public void verifyPageTitle() {
JavascriptExecutor js = (JavascriptExecutor) driver;
String title = (String) js.executeScript(
"return document.title;"
);
Assert.assertNotNull(title);
}
JavascriptExecutor js = (JavascriptExecutor) driver;
String title = (String) js.executeScript("return document.title;");
String url = (String) js.executeScript("return location.href;");
String state = (String) js.executeScript("return document.readyState;");
System.out.println("Title: " + title);
System.out.println("URL: " + url);
System.out.println("Ready State: " + state);
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement submit = wait.until(
ExpectedConditions.elementToBeClickable(By.id("submit"))
);
JavascriptExecutor js = (JavascriptExecutor) driver;
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
submit
);
submit.click();
WebElement input = driver.findElement(By.id("username"));
String value = (String) js.executeScript(
"return arguments[0].value;",
input
);
String placeholder = (String) js.executeScript(
"return arguments[0].getAttribute('placeholder');",
input
);
System.out.println("Value: " + value);
System.out.println("Placeholder: " + placeholder);
WebElement element = driver.findElement(By.id("username"));
js.executeScript(
"arguments[0].style.border='3px solid red';",
element
);
Boolean visible = (Boolean) js.executeScript(
"return arguments[0].getClientRects().length > 0;",
element
);
System.out.println("Has Layout Box: " + visible);
js.executeScript(
"window.localStorage.setItem('testMode', 'true');"
);
String mode = (String) js.executeScript(
"return window.localStorage.getItem('testMode');"
);
System.out.println("Test Mode: " + mode);
String language = (String) js.executeScript(
"return navigator.language;"
);
String userAgent = (String) js.executeScript(
"return navigator.userAgent;"
);
System.out.println("Language: " + language);
System.out.println("User Agent: " + userAgent);
JavaScriptExecutor can be used in automated test pipelines for browser-side inspection and specialized scrolling or DOM operations. Tests should still use stable locators, explicit waits, useful logging, and proper error handling.
When tests run in Chrome, Firefox, Edge, or other supported browsers, validate the behavior across the target browsers. Do not assume every browser will render or expose every browser-side behavior identically.
| WebDriver | JavaScriptExecutor |
|---|---|
| Automates browser interactions through Selenium. | Executes JavaScript in the browser context. |
| Preferred for clicks, typing, navigation, and context switching. | Useful for DOM inspection and specialized browser operations. |
| Supports explicit wait conditions. | Can return browser-side information for custom checks. |
| Actions Class | JavaScriptExecutor |
|---|---|
| Used for mouse and keyboard interactions. | Used to execute browser-side JavaScript. |
| Supports hover, drag and drop, and key combinations. | Supports DOM inspection, scrolling, and specialized operations. |
| Useful for user-like interactions. | Useful for browser-side investigation and scripting. |
JavascriptExecutor is a Selenium interface that allows Java programs to execute JavaScript code in the browser.
JavascriptExecutor js = (JavascriptExecutor) driver;executeScript() executes JavaScript synchronously and returns the result as an Object.
executeAsyncScript() supports asynchronous JavaScript and waits for the supplied callback, subject to the configured script timeout.
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
element
);
js.executeScript(
"window.scrollTo(0, document.documentElement.scrollHeight);"
);
String title = (String) js.executeScript("return document.title;");arguments[0] refers to the first argument passed from Selenium to the JavaScript code.
Yes. It can return supported values such as strings, numbers, booleans, WebElements, and supported JavaScript collections or objects.
No. WebDriver remains the primary browser automation API. JavascriptExecutor complements it for specialized browser-side operations.
| Method or Property | Purpose |
|---|---|
| executeScript() | Executes synchronous JavaScript. |
| executeAsyncScript() | Executes asynchronous JavaScript using a callback. |
| document.title | Returns the page title. |
| window.location.href | Returns the current URL. |
| document.readyState | Returns the document loading state. |
| window.scrollBy() | Scrolls relative to the current position. |
| window.scrollTo() | Scrolls to specified coordinates. |
| scrollIntoView() | Scrolls an element into view. |
| arguments[0] | References the first passed argument. |
| localStorage | Stores browser data persistently for the origin. |
| sessionStorage | Stores browser data for the relevant page session. |
JavaScript execution is a useful advanced feature in Selenium automation. The JavascriptExecutor interface helps testers inspect browser information, read DOM properties, scroll pages, investigate dynamic content, and perform specialized browser-side operations.
For reliable automation, JavaScriptExecutor should complement rather than replace standard Selenium WebDriver APIs. Use WebDriver for normal user interactions, explicit waits for synchronization, and JavaScript for clearly justified browser-side tasks. This approach helps create maintainable, reliable, and meaningful automation tests.
Explore the JustAcademy Selenium Training Course for learning Selenium WebDriver, Java automation, TestNG, locators, waits, framework development, cross-browser testing, and practical automation projects.
For course enquiries and demo registration, visit Register for Course Demo.
