Selenium JavaScript Tutorial: Examples and Best Practices

Why Use JavaScript for Selenium Automation?

You use JavaScript for Selenium so your team can automate in the same language it builds the app in, reusing one toolchain, the npm ecosystem, and native async handling.

JavaScript is the default language of the web, so writing your Selenium tests in it removes friction for the people most likely to own those tests: the developers who already wrote the app. In the Stack Overflow 2025 Developer Survey, JavaScript was again the most-used programming language, reported by 66% of all respondents. That reach is exactly why a JavaScript test stack is easy to staff and easy to review.

Choosing JavaScript for Selenium automation testing gives you concrete advantages:

• One language across the stack: Your app, your unit tests, and your end-to-end Selenium tests all live in JavaScript, so reviewers do not switch mental models.
• A huge ecosystem: npm gives you ready-made test runners, assertion libraries, and reporters that drop straight into a Selenium project.
• Native async handling: Modern Selenium JavaScript uses async/await, which maps cleanly onto how the browser and network actually behave.
• A strong fit for JS frameworks: Apps built in React, Angular, or Vue are a natural match for tests written in the same language.

Selenium is one well-supported route into JavaScript automation testing, sitting alongside runner-driven options that you can compare with other popular JavaScript testing frameworks before selecting the right stack for your project.

Selenium vs JavaScript: Clearing Up the Confusion

A lot of people search for "selenium vs javascript" as if you have to pick one. You do not. They sit at different layers, and you use them together.

"Selenium JavaScript" simply means you are calling Selenium WebDriver through its official JavaScript binding, the selenium-webdriver npm package.

The same framework also has bindings for Java, Python, C#, and Ruby, so the WebDriver concepts you learn here can be applied across different languages.

If you want to deepen your understanding, follow Selenium testing tutorial to explore more advanced automation patterns and best practices. The only real decision is which language your team is fastest in, and for web teams, that answer is usually JavaScript.

How to Set Up Selenium With JavaScript

Selenium JavaScript runs on Node.js, so your setup is short. You need three things: the Node.js runtime, the selenium-webdriver package, and a browser driver.

Step 1: Install Node.js: Download the latest LTS build from the official Node.js site. It bundles npm, the package manager you will use to pull in Selenium. Confirm both are available:

node -v
npm -v

Step 2: Create a project and install Selenium: The current release of the JavaScript binding is selenium-webdriver 4.44.0, which follows the W3C WebDriver standard.

mkdir selenium-js-demo && cd selenium-js-demo
npm init -y
npm install selenium-webdriver

Step 3: Get a browser driver: Selenium 4 ships with Selenium Manager, which downloads the matching driver (ChromeDriver, GeckoDriver, and so on) automatically the first time you run a test, so for local Chrome or Firefox you usually do not install anything else. With setup done, you are ready to write a test.

With the setup complete, you can start writing and running tests immediately. If you're familiar with older Selenium releases, Selenium 4 includes several important changes beyond driver management that can affect how existing test suites behave.

Everything here runs on Selenium 4, which replaced the legacy JSON Wire protocol with the native W3C WebDriver standard and introduced relative locators and a redesigned Grid. Follow this detailed Selenium 4 tutorial to explore these features in depth and understand how they can affect existing test suites during an upgrade.

How to Write Your First Selenium JavaScript Test

To write your first Selenium JavaScript test, build a driver, open the page, find an element, perform an action like typing or clicking, check the result, then close the browser session.

This first test opens the Selenium Playground, submits a message through the Simple Form Demo, and checks that the page echoes it back. Save it as firstTest.js:

const { Builder, By, until } = require("selenium-webdriver");

(async function firstTest() {
  const driver = await new Builder().forBrowser("chrome").build();
  try {
    await driver.get("https://www.testmuai.com/selenium-playground/");
    await driver.findElement(By.linkText("Simple Form Demo")).click();

    const message = "Welcome to TestMu AI";
    await driver.findElement(By.id("user-message")).sendKeys(message);
    await driver.findElement(By.id("showInput")).click();

    const output = await driver
      .wait(until.elementLocated(By.id("message")), 5000)
      .getText();
    console.log("Displayed message:", output);
  } finally {
    await driver.quit();
  }
})();

Run it with node firstTest.js. A Chrome window opens, fills the form, and prints the echoed message to your terminal. A few things are worth noticing: every WebDriver call returns a promise, so you await it; until.elementLocated waits for the result element instead of guessing with a fixed sleep; and the finally block guarantees the browser closes even if an assertion fails.

Want the same example explained step by step on video?

Once this script passes locally, you'll typically move it into a test runner. Test runners provide structure for organizing tests, executing suites, generating reports, and managing assertions as your automation project grows. Mocha is a popular lightweight choice for Selenium test suites, while Jest provides built-in assertions, mocking, and a more opinionated testing experience for JavaScript projects.

Understanding the differences in a Jest vs Mocha comparison can help you choose the framework that best matches your testing workflow.

Core Building Blocks of Selenium JavaScript Tests

Almost every Selenium JavaScript test is built from three ideas: finding elements, waiting for them, and occasionally dropping into raw JavaScript when WebDriver alone cannot reach something.

await driver.findElement(By.id("user-message"));        // most stable
await driver.findElement(By.name("q"));
await driver.findElement(By.css("button.submit"));
await driver.findElement(By.linkText("Simple Form Demo"));
await driver.findElement(By.xpath("//button[text()='Get Checked Value']")); // last resort

// Good: waits only as long as needed, up to 10 seconds
const message = await driver.findElement(By.id("message"));
await driver.wait(until.elementIsVisible(message), 10000);

// Avoid: blocks for a fixed time whether the element is ready or not
await driver.sleep(10000);

// Scroll an element into view, then read a value straight from the DOM
const button = await driver.findElement(By.id("showInput"));
await driver.executeScript("arguments[0].scrollIntoView(true);", button);

const title = await driver.executeScript("return document.title;");
console.log("Page title:", title);

Running Selenium JavaScript Tests Across Browsers on the Cloud

Maintaining every browser and OS version on local machines does not scale. Cloud-based Selenium testing allows you to run the same test suite across multiple real browsers, operating systems, and devices in parallel without managing infrastructure yourself.

One such cloud platform is TestMu AI (formerly LambdaTest), a Full Stack Agentic AI Quality Engineering platform that helps teams test intelligently and ship faster. Beyond scalable Selenium testing, it provides end-to-end AI agents that help teams plan, author, execute, and analyze software quality across web, mobile, and enterprise applications.

By connecting your Selenium tests to the TestMu AI cloud, you can execute them across thousands of real browser and OS combinations, real devices, and custom real-world environments while benefiting from enterprise-grade scale, observability, and AI testing insights.

const { Builder } = require("selenium-webdriver");

const capabilities = {
  browserName: "Chrome",
  browserVersion: "latest",
  "LT:Options": {
    platformName: "Windows 11",
    build: "Selenium JavaScript Demo",
    name: "First cloud test",
    user: process.env.LT_USERNAME,
    accessKey: process.env.LT_ACCESS_KEY,
  },
};

(async function cloudTest() {
  const driver = new Builder()
    .usingServer("https://hub.lambdatest.com/wd/hub")
    .withCapabilities(capabilities)
    .build();
  try {
    await driver.get("https://www.testmuai.com/selenium-playground/");
    console.log("Page title:", await driver.getTitle());
  } finally {
    await driver.quit();
  }
})();

Set your LT_USERNAME and LT_ACCESS_KEY as environment variables, then update the browserName and platformName capabilities to run the same test across different browser and operating system combinations. This allows you to validate cross-browser behavior on Chrome, Firefox, Edge, and Safari while scaling execution through TestMu AI's cloud infrastructure.

To get started with Selenium JavaScript automation on TestMu AI, follow the support documentation on Selenium With JavaScript.

Run JavaScript Selenium Tests Using Agent Skills

Use AI coding assistants to generate and run JavaScript Selenium tests with the TestMu AI Agent Skill. The selenium-skill is part of TestMu AI agent-skills, a collection of structured packages that teach AI coding assistants how to write production-grade Selenium test automation and execute it on TestMu AI.

These Selenium Skills help standardize automation workflows, making it easier to apply Selenium with AI techniques for test creation, maintenance, and execution. As AI-assisted development becomes more common, they also support emerging vibe testing with Selenium workflows, where natural language prompts are used to generate and refine automated tests.

Install the skill:

git clone https://github.com/LambdaTest/agent-skills.git
cp -r agent-skills/selenium-skill .claude/skills/

# For Cursor / Copilot
cp -r agent-skills/selenium-skill .cursor/skills/

Once installed, your AI coding assistant can generate and run JavaScript Selenium tests using the TestMu AI Agent Skill, helping teams adopt Selenium AI workflows without changing their existing automation stack. For a complete setup and usage, follow the support documentation on running Selenium tests with Agent Skills.

Selenium JavaScript Best Practices

A test suite that runs green today but breaks every sprint is worse than no suite at all. These Selenium best practices help keep your JavaScript tests fast, readable, and trustworthy as your automation suite grows.

• Replace every sleep with an explicit wait: Fixed delays either waste time or fire too early. Proper use of Selenium waits helps synchronize tests with the application state and reduces flaky failures.
• Use the Page Object Model: Keeping locators and page actions in dedicated page object classes means a UI change touches one file, not fifty tests. The Selenium Page Object Model(POM) helps improve maintainability by separating test logic from page-specific implementation details.
• Prefer stable locators: Lean on IDs and data attributes over brittle XPath tied to page layout. Many teams use data attributes in JavaScript with Selenium to create selectors that remain stable across design and layout updates.
• Keep tests independent: Each test should create its own preconditions and avoid relying on data or state left behind by other tests. Independent tests can run in any order, execute in parallel, and produce more reliable results.
• Capture evidence on failure: A screenshot taken the moment a test fails turns a vague stack trace into an obvious visual clue and cuts debugging time. Capturing screenshots in Selenium WebDriver using JavaScript is a simple but effective way to speed up root cause analysis.
• Test across real browsers early: A test that passes only in your local Chrome is not cross-browser coverage. Early cross-browser testing helps identify JavaScript browser compatibility issues that can behave differently across browser engines and versions.

Selenium JavaScript Resources

Once you are comfortable with the basics above, these guides take each topic further. They are grouped so you can jump to what you need next.

Choose and learn a framework

• Top JavaScript testing frameworks
• Jest vs Mocha vs Jasmine.
• Jest tutorial for Selenium JavaScript testing.
• Mocha JavaScript tutorial.
• Cucumber.js tutorial for Selenium.
• Selenium automation testing with the Cucumber.js framework.

Master the core techniques

• JavaScript wait in Selenium WebDriver.
• JavaScriptExecutor in Selenium WebDriver.
• Handling frames and iframes in Selenium JavaScript.
• Page Object Model in JavaScript with Selenium.
• Get data of attributes in JavaScript with Selenium.
• Taking screenshots in Selenium WebDriver using JavaScript.
• Using strings in JavaScript with Selenium WebDriver.

Cross-browser and scaling

• JavaScript cross-browser compatibility issues and how to solve them.
• Fixing JavaScript cross-browser compatibility issues.
• Speed up JavaScript testing with Selenium and WebdriverIO.

Sharpen your JavaScript skills

• 21 tips to become better in JavaScript.
• 13 JavaScript testing best practices you should know.
• Best books for JavaScript beginners.
• 19 JavaScript interview questions.

Conclusion

Start small: install Node.js, run the firstTest.js script above against the Selenium Playground, and confirm it prints the echoed message. From there, wrap it in Mocha or Jest, move your locators into Page Objects, and swap fixed sleeps for explicit waits. Those few habits are what separate a suite you trust from one you fight.

When you're ready to test beyond your local machine, point your Selenium suite at the TestMu AI cloud grid and execute it across 3,000+ browser and OS combinations and 10,000+ real devices in parallel. Combined with AI test authoring, execution, and analysis, this allows teams to scale Selenium JavaScript automation without adding infrastructure or maintenance overhead.