Selenium 1 vs. Selenium 2: Key Differences and Status

Direct answer: Selenium 1 is commonly associated with Selenium RC, which ran automation through JavaScript inside the browser. Selenium 2 brought Selenium and WebDriver together: WebDriver controlled browsers through browser-specific implementations, while the project retained Selenium lineage. Selenium 1 and 2 are legacy generations; for new work, use current Selenium documentation and releases.

The practical difference is the browser-control model. RC depended on code running in the browser, which encountered limits such as the same-origin restriction. WebDriver controlled the browser through its driver implementation and could use native platform facilities. Selenium 2 was a project merger, not a wholly unrelated replacement. [Selenium 2 FAQ, 2010 project status post]

What is the difference between Selenium 1 and Selenium 2?

Area	Selenium 1 / Selenium RC	Selenium 2 / WebDriver
How it controlled the browser	Automation ran as JavaScript within the browser.	WebDriver controlled the browser through browser-specific implementations.
Key architectural consequence	In-browser JavaScript faced browser security limits, including the same-origin problem.	Could use facilities exposed by the native platform instead of relying on browser JavaScript for the main control path.
Project relationship	Original Selenium API and code lineage.	A merger of Selenium and WebDriver, combining Selenium lineage with WebDriver APIs and browser drivers.
Current status	Legacy.	Legacy; current Selenium releases are in the 4.x series.

What is Selenium RC?

Selenium RC, or Remote Control, is the interaction model most often meant by “Selenium 1.” It used a server and browser-side JavaScript to issue commands. Because the command execution relied on JavaScript inside the page’s browser context, browser security rules constrained what automation could do.

“Selenium 1” and “Selenium RC” are closely related terms, but Selenium also refers to the broader project and its APIs. Keep that distinction in mind when reading old code or migration notes.

What changed with WebDriver?

WebDriver shifted the main control mechanism out of page JavaScript and into browser-specific implementations. That made automation more representative of browser behavior and allowed it to use native platform facilities. The Selenium FAQ summarizes the distinction as WebDriver controlling the browser itself rather than running as a JavaScript application within it. [Official FAQ]

That architectural description does not establish that WebDriver is faster or more reliable in every workload. The reviewed project sources provide no comparative benchmark, so performance should be measured in the actual browser, application, and test environment.

Was Selenium 2 a replacement or a merger?

It was a merger. The Selenium project’s 2010 status post explains that the Selenium and WebDriver codebases had been combined. It also described the early 2.x releases as containing Selenium 1.x code and being backward compatible at that point. Treat that as a historical description of early Selenium 2, not a compatibility promise for every later binding or present-day release. [Project status post]

The legacy Selenium 2 documentation describes Selenium 2 as a rewrite of Selenium 1 implemented with WebDriver code. Read alongside the project’s contemporaneous account, the useful takeaway is that Selenium 2 combined the lineages and APIs; it was not simply a clean break with no shared history. [Selenium 2 legacy documentation]

Is Selenium 2 still supported?

Selenium 2 is a legacy generation, as is Selenium 1. The Selenium project’s downloads page lists Selenium 4 releases for its language bindings and Server/Grid. The dossier’s current check recorded Selenium 4.49.0, dated September 9, 2026; release listings change, so consult the official page for the latest version when upgrading. [Selenium downloads]

For active projects, use the current WebDriver documentation and the upgrade instructions for the language binding you use. Selenium 3 supported both W3C WebDriver and the older JSON Wire Protocol; the official Selenium 4 upgrade guide covers changes involved in moving from Selenium 3. [Upgrade to Selenium 4]

How do I migrate from Selenium RC to WebDriver?

There is no single safe code edit for every RC suite. First identify which language binding and legacy APIs the project uses, then migrate and validate in small steps against the current instructions for that binding. Selenium’s legacy documentation points to RC-to-WebDriver migration material; current Selenium 4 guidance is organized around binding and API behavior, rather than a universal conversion recipe. [Legacy Selenium 2 documentation, Selenium 4 upgrade guide]

Inventory the environment. Record the language, Selenium package version, browser versions, driver setup, and whether execution is local or through Selenium Server/Grid.
Find RC dependencies. Search for Remote Control clients, RC server startup, and APIs specific to the old Selenium interface. Separate those from application test logic.
Choose the supported destination. Use the current Selenium binding and follow its official installation and upgrade documentation. Do not assume that a Selenium 2 compatibility statement from 2010 guarantees source compatibility today.
Port a small representative test. Start with navigation and a simple element interaction, then handle waits, browser setup, windows, frames, and other suite-specific behavior.
Run against the target browsers. Check that the new driver and browser versions are compatible, and compare behavior for timing-sensitive tests.
Expand by test group. Keep the migration reviewable, and use failures to identify obsolete APIs or assumptions about browser behavior.

This checklist is migration planning guidance, not a claim that the Selenium project prescribes those exact steps. The official binding-specific instructions take precedence.

How to capture a website screenshot with Selenium WebDriver

Selenium is a browser automation framework, so it can capture screenshots as part of a browser workflow. The small Python example below uses the current WebDriver API style. Install the Selenium Python package and have a compatible browser and driver available according to the official binding setup instructions. Replace the URL with a page you are permitted to access.

from selenium import webdriver
from selenium.webdriver.chrome.options import Options

options = Options()
options.add_argument("--headless")
driver = webdriver.Chrome(options=options)
try:
    driver.set_window_size(1440, 1000)
    driver.get("https://example.com")
    driver.save_screenshot("screenshot.png")
finally:
    driver.quit()

This captures the current viewport. A full-page screenshot is not standardized as one cross-browser WebDriver operation; techniques vary by browser and driver. Also, setting a viewport does not guarantee that every lazy-loaded element has been fetched. Scroll or wait for the page’s own content when the capture requires it, and make the wait condition specific to the page.

Or skip the browser setup

If the goal is a screenshot rather than a browser automation suite, ScreenshotNeo is the alternative to try first: one GET request returns an image or PDF, and its API supports full-page capture and many browser settings. See the API documentation.

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://example.com -o shot.webp

import requests

r = requests.get(
    "https://api.screenshotneo.com/v1/shot",
    params={"access_key": "YOUR_API_KEY", "url": "https://example.com"},
    timeout=90,
)
open("shot.webp", "wb").write(r.content)

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://example.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);
if (!res.ok) throw new Error(`Screenshot request failed: ${res.status}`);
const bytes = new Uint8Array(await res.arrayBuffer());
await (await import('node:fs/promises')).writeFile('shot.webp', bytes);

Cookie banners are accepted and removed before capture, along with known newsletter popups and chat widgets; each step can be turned off.
Bot checks, blank pages, failed loads, timeouts, and cache hits are not billed. Response headers report the page verdict and billing status.
An MCP server lets AI agents use the take_screenshot, get_page_info, and capture_pdf tools.
1,000 screenshots per month are free with no card; paid plans start at $5 for 3,000 screenshots.

Performance, reliability, and cost considerations

Performance: No benchmark in the cited project sources establishes a speed winner between Selenium 1 and 2. Browser startup, page loading, waits, driver communication, and test design all affect elapsed time. Measure your own workload.
Reliability: WebDriver’s browser-specific control model avoids the RC model’s reliance on in-browser JavaScript for core control, but it does not eliminate application timing issues, incompatible browser and driver versions, or network failures.
Maintenance: Both generations are legacy. Staying on an old generation can leave you tied to old packages and APIs; base upgrade decisions on current Selenium binding documentation.
Cost: Selenium itself does not imply a per-screenshot API charge in this comparison. Account for the infrastructure and engineering time needed to run browsers and maintain automation. ScreenshotNeo’s stated plans are Free for 1,000 shots monthly, Starter $5 for 3,000, Growth $15 for 15,000, Pro $39 for 60,000, Scale $99 for 250,000, and Business $249 for 1,000,000; yearly billing gives two months free, and every feature is on every plan.

Troubleshooting legacy Selenium code and WebDriver

Symptom	Likely cause	What to do
Old RC client cannot start or connect	The test depends on a legacy RC server or client that is not part of the current WebDriver setup.	Identify the RC-specific dependency and follow migration instructions for the language binding. Do not assume changing only the package version will convert RC calls.
Element lookup or interaction fails after migration	Legacy API usage or assumptions about page timing differ from the WebDriver flow.	Check the binding’s current API documentation, and wait for a meaningful page condition instead of relying on fixed timing.
Browser fails to launch	Browser, driver, Selenium binding, or runtime versions may not work together, or the environment lacks required browser dependencies.	Check the binding’s installation instructions and the browser/driver setup for the environment; capture the complete startup error before changing versions.
Test passes locally but fails in another environment	Different browser versions, viewport, timing, network access, or execution environment can change behavior.	Record these settings and make waits and test data explicit. Reproduce with the same browser and driver combination.
Screenshot omits content	The content may be below the fold, lazy-loaded, covered by a popup, or not ready when capture runs.	Wait for a page-specific readiness condition; scroll to trigger lazy loading if needed. For full-page capture, use a browser-specific method or a screenshot API that supports it.

Frequently asked questions

Is Selenium 2 the same as WebDriver?

No. WebDriver was a major part of Selenium 2, but Selenium 2 represented the merger of Selenium and WebDriver, including Selenium APIs and code lineage.

Does Selenium 2 code always run on a modern Selenium release?

No universal compatibility guarantee follows from the early Selenium 2 backward-compatibility description. Check the current instructions for your language binding and the APIs your code uses.

Should a new project use Selenium 1 or Selenium 2?

Neither legacy generation is the current choice. Start with current Selenium documentation and releases, and select the supported binding and browser setup for the project.

Was Selenium 1.0.4 definitely the final 1.x release?

The project’s July 2010 post said 1.0.4 was planned as the final 1.x release. That source establishes the plan at the time, not an independently verified release-history claim. [2010 status post]