What Are the Four Types of Selenium?

Isometric workbench with four small looms, three working with green pegs and one dusty retired loom with a red pin

TL;DR: Selenium has three active components. Selenium WebDriver drives real browsers through code in Java, Python, C#, JavaScript, or Ruby. Selenium IDE is a browser extension that records and plays back clicks. Selenium Grid runs WebDriver sessions in parallel across machines and browsers. Selenium RC, the original remote control server, is deprecated, and WebDriver has replaced it. Teams moving off Selenium can bring their suites into ContextQA, the autonomous quality engineer.

The four types of Selenium are Selenium IDE, Selenium RC, Selenium WebDriver, and Selenium Grid. RC is no longer part of current releases. If you are auditing a legacy suite or planning a migration, the components each test depends on set the scope of the work.

Quick answers

What are the four types of Selenium? The Selenium project is usually described as four components: Selenium IDE, Selenium RC, Selenium WebDriver, and Selenium Grid. IDE is a browser extension for recording and playing back tests. RC (Remote Control) was the original server based driver, and WebDriver has replaced it. WebDriver drives browsers through native browser drivers, and Grid runs WebDriver sessions in parallel across machines and browsers.

Is Selenium RC still used, and should a team migrate off it? Selenium RC is deprecated and was removed from the main Selenium distribution, so new work should not target it. Move any suite still on RC APIs to WebDriver or to another maintained platform. Start from a versioned repository and a recorded baseline run. Migrate what each test is meant to verify, not its old commands, and confirm each migrated test against the same build with one test that should pass and one that should fail.

Which Selenium component should a QA lead standardize on for CI/CD pipelines? For CI/CD, standardize on Selenium WebDriver for test code and add Selenium Grid when you need parallel runs across several browsers. Selenium IDE works for quick prototypes, but recorded scripts are hard to review, version, and maintain at scale. Before adding tests, list your runner, page objects, waits, and Grid capabilities, because hidden sleeps and race conditions are a common cause of flaky tests.

What are the types of Selenium?

The types of Selenium are its four components: WebDriver, IDE, Grid, and the retired RC. Each works at a different layer, so the one you choose decides who can write tests, how they run in CI, and what you will migrate later. The official Selenium documentation covers the three current components.

  • WebDriver: a language binding that sends commands to a browser driver such as chromedriver. Use it for maintained regression suites in a runner like JUnit or pytest.
  • IDE: a record and playback extension that saves .side project files. Use it for quick reproductions, not long lived suites.
  • Grid: a hub and node setup that runs tests across browsers and operating systems through RemoteWebDriver.
  • RC: a legacy API. Treat any RC code as migration debt and start no new work on it.

What can each Selenium component do?

Together, the Selenium components cover the full browser automation loop: IDE records and replays flows, WebDriver drives real browsers from code, and Grid runs those sessions in parallel across machines, browsers, and operating systems. Selenium 4 changed how each one talks to browsers and how Grid is deployed.

  • W3C protocol: Selenium 3 used the older JSON Wire Protocol. Selenium 4 uses the W3C WebDriver standard directly, removing a translation layer between client libraries and browser drivers.
  • New locators and browser hooks: Selenium 4 adds relative locators such as above() and toLeftOf(), switchTo().newWindow() for tabs, and WebDriver BiDi access for capturing network and console output.
  • Grid modes: per the Selenium Grid documentation, the standalone subcommand runs every Grid component in one process, which fits a laptop or single CI agent. The hub and node subcommands split session routing from browser hosts. Distributed mode runs the router, distributor, session map, session queue, and event bus as separate processes, so large suites can scale each one, for example on Kubernetes.
Overhead view of hands typing on a silver laptop set against a background of white binary digits on black

Why does the choice of Selenium component matter in 2026?

Your Selenium choices in 2026 decide who can maintain the suite, how it scales in CI, and how hard a later migration will be. Those choices are the component, the language binding, the locator strategy, and the framework pattern. Picking them out of habit, rather than from team skills, leads to flaky tests and ownership gaps.

Language bindings. Pick the binding your application team already writes, so developers can review the test code. In the Stack Overflow Developer Survey 2024, 62.3% of respondents used JavaScript, 51% used Python, 30.3% used Java, and 27.1% used C#.

Locators. The Selenium locator documentation lists eight strategies, including id, css selector, and xpath. Use id and stable CSS first. Long xpath chains break on small DOM changes.

Framework patterns. Java teams use TestNG or JUnit to run one test with many data sets, and Python teams use pytest fixtures for setup. The Page Object Model puts each screen's locators in one class. ContextQA's Selenium migration guide notes that page objects, waits, and framework hooks may not map one to one when you move a suite.

How do the Selenium components work together?

All three active Selenium components build on the same protocol. IDE records actions as scripts you can replay or export, WebDriver sends commands from your code to a browser driver over the W3C WebDriver protocol, and Grid routes those sessions to remote machines so one suite runs in parallel.

  1. Record in IDE. The extension saves clicks and typing as a .side project you can replay or export to WebDriver code.
  2. Execute with WebDriver. A call such as driver.findElement() becomes an HTTP request to a driver like chromedriver, which Selenium Manager locates and sets up.
  3. Synchronize explicitly. Actions do not wait for the page on their own, so teams add WebDriverWait conditions. Missing waits and leftover Thread.sleep() calls cause flaky failures.
  4. Scale through Grid. Run java -jar selenium-server-<version>.jar hub, register nodes with node, and the router sends each session to a node matching the requested capabilities.

For enterprise teams, most maintenance cost sits in steps 3 and 4. Locators, wait logic, and Grid hosts all need an owner.

Which approach fits your team?

Pick based on who will own maintenance. Teams with strong SDETs (software development engineers in test) and a stable UI usually keep WebDriver on a self hosted Grid. Teams needing more browsers and devices than they can host move execution to a cloud grid. Teams losing hours to broken locators should evaluate an AI platform with self healing.

OptionBest forPricing modelNotable tradeoff
Self hosted Selenium GridTeams with infra and SDET capacityOpen source, plus servers and upkeepYou patch nodes, drivers and browsers
Cloud testing gridWide browser and real device coverageSubscription, often priced by parallel sessionsFaster runs, same flaky scripts
AI platform with self healingSuites where locator repair dominatesQuote based (ContextQA: demo and quote)Migration effort, plus review of healed steps

When you work out ROI (return on investment), remember that a cloud grid lowers infrastructure cost but not script maintenance. Self healing repairs selectors after UI changes. It does not fix race conditions caused by bad waits.

How does ContextQA handle the types of Selenium?

A ContextQA migration starts from an inventory of the versioned repository, covering whichever Selenium components the suite uses. WebDriver repositories go through the documented MCP (Model Context Protocol) analysis and dry run. IDE recordings are not a code repository, so you rebuild them through a staged conversion.

  • WebDriver suites. The Selenium migration guide has you record the commit SHA, runner, Grid settings, and capability matrix before migrating a representative slice. It reads each page object method for hidden waits, frame switching, and assertions instead of translating it by name.
  • Grid. Record your Grid configuration and capability matrix in the baseline, then choose the browsers and devices the migrated suite should run on. You still need a plan for data isolation.
  • IDE. Extract the business intent, rebuild the flow in the no code recorder, refine it in the Test Steps Editor, and compare results with the source run.

Your Jenkins or GitHub Actions jobs stay in place, and the platform adds self healing and root cause analysis. Migrated tests export as Playwright code, so there is no lock in. Check each migrated case against the same build with a passing control and a deliberately failing one.

If your Selenium suite breaks with every UI change, book a demo to see how ContextQA migrates a representative slice and self heals it.
Top-down close-up of a silver laptop keyboard corner with black return, shift, delete and arrow keys

What should you do now? A checklist

Start by confirming which Selenium components your suite actually uses. Then pin versions, record a baseline at one commit, find the hidden waits, and decide whether to keep, consolidate, or migrate each part.

  • Search the repo for org.openqa.selenium, selenium-webdriver, or from selenium import webdriver to confirm WebDriver usage.
  • Search for com.thoughtworks.selenium or DefaultSelenium to find RC code.
  • List every .side file. Each one is an IDE recording.
  • Find RemoteWebDriver endpoints or Grid config.toml files to confirm Grid usage.
  • Record Selenium, browser, and driver versions from your lockfile and CI logs.
  • Run the suite at one full commit SHA and save the runner report as your baseline.
  • Grep for Thread.sleep and time.sleep. Each hit is a likely source of flaky waits.
  • Note which page object methods hide waits, frame switches, or assertions.
  • Name an owner for each suite and for failed run triage.
  • Migrate one representative flow and verify it with a control test that should pass and one built to fail.

Bottom line

Selenium has four components: IDE for recording, the retired RC, WebDriver for driving browsers from code, and Grid for parallel sessions. Standardize CI on WebDriver plus Grid, treat RC as migration debt, and keep IDE for prototypes. If infrastructure is the bottleneck, buy grid capacity. If maintenance is, change how tests are written and repaired. Related: Selenium IDE and self healing.

Sources

Share the Post:

Author

Deep Barot

CEO @ ContextQA | Agentic AI for Software Testing | Context-aware Testing

Deep Barot is the Founder and CEO of ContextQA, the only AI testing platform that understands context. He brings decades of experience across DevOps, full-stack engineering, cloud systems, and large-scale platform development.
AI Insights
Real User Intelligence Platform

Turn live sessions into test coverage. No prompts, no manual design - just pointed at your URL and generating suites within minutes.

Minutes
From URL to generated test cases
Zero
Prompts or manual test design needed
40%+
Average coverage increase after first run
100%
Based on real user behavior, not guesses

Frequently Asked Questions

Selenium WebDriver is the browser automation API your test code calls. Selenium Grid runs those WebDriver sessions in parallel across remote machines and browsers. Selenium IDE is a browser extension that records and plays back user actions. In a migration, most of the inventory work is in the WebDriver code and the Grid capabilities.
Pick TypeScript if your team already writes it or keeps a large suite of page objects, because typed locators and helper signatures catch broken refactors at compile time. JavaScript is fine for small suites. Either way, test intent and wait handling matter more than the language.
For new web suites, Playwright with TypeScript is often the better fit because it waits for elements automatically and can record traces when you turn them on, for example on the first retry. Selenium is still a strong choice when you need many languages, an existing Grid, or mature page objects. Choose based on the stack and skills your team already has.
Related Blogs