Selenium IDE: How to Record and Replay Browser Tests

Selenium IDE is a browser extension that records browser actions as Selenium commands and replays them in a browser. To get started, install it in a supported browser, create a project with your application’s base URL, record a workflow, save the project as a .side file, and use the play control to replay the test or suite. Selenium lists Chrome, Firefox, and Edge for IDE availability; check the live extension listing and current release notes for the latest details. Selenium IDE overview · Selenium downloads and release links.

What Selenium IDE records

Selenium IDE captures browser interactions as commands in a test. It is a low-code way to start browser automation and learn Selenium command syntax. A recording is a useful draft of the workflow: replay it, inspect the recorded commands and targets, and edit steps that do not express the check you intend. A recorded sequence does not automatically guarantee a reliable or maintainable test.

The workflow below follows Selenium’s getting-started guide. Interface labels may change between releases, so use the live extension UI if a label differs. See the official getting-started guide.

Install Selenium IDE and create a project

Install Selenium IDE from the extension store for your browser. Selenium’s overview lists Chrome, Firefox, and Edge. The official guide includes Chrome and Firefox store instructions; confirm current availability in the relevant store.
Launch Selenium IDE from the browser’s extension menu.
In the welcome dialog, choose the option to record a new test in a new project.
Enter a project name and the base URL of the application you want to test. The base URL belongs to the project settings and can be changed later.
Let Selenium IDE open the application in a browser window. Perform the workflow you want to capture in that window.

Use a stable, non-sensitive test account and test data where possible. Recording can capture actions and targets tied to the current page state; do not use it to handle real customer data or production transactions.

Record a new test

Start the recording flow from the new-project dialog, or open a project and start a new recording using the current IDE controls.
In the browser window Selenium IDE opens, carry out the browser workflow in the order a user would perform it. For example, navigate to a test page, open a menu, fill in a form, and submit it.
Switch back to Selenium IDE and click its recording control to stop.
Review the generated commands in the test editor. Add or edit commands manually when the recorded sequence needs a clearer action or assertion.
Use the sidebar to add another test if needed. Group related tests in suites; a new project creates a Default Suite and adds its first test there.
Save the project with the save control. Selenium IDE saves the project as one .side file.

Keep each test focused on one user-visible workflow or outcome. If a test has several unrelated journeys, split it into separate tests so that a failure points to a smaller part of the application.

Replay a test or suite

Open the saved project in Selenium IDE.
Select the test or suite you want to run.
Click the play control above the test editor.
Watch the browser window and the IDE’s command playback to locate any step that fails.

If the browser window used for recording remains open, IDE playback reuses it. If it has been closed, IDE opens another browser window for playback. After a run, inspect the commands and targets around a failure instead of assuming the application itself is at fault.

Make a recording useful as a test

A recording captures what happened during one session. Review it before treating it as a regression test:

Check the intended result. Make sure the test contains a meaningful check for the outcome you care about, not only the clicks that led there.
Review targets. Confirm that each command points to the intended element and still makes sense after page changes.
Remove accidental actions. Delete exploratory clicks, pauses, or navigation that are not part of the scenario.
Keep setup predictable. Use known test data and reset state when repeated runs would otherwise depend on prior runs.
Run it again. Replay after edits and after changes to the test data or application page.
Save the project. Keep the .side file under the project’s normal version-control and review process if the team maintains tests that way.

These are practical maintenance steps, not a guarantee that every recording will be stable. Browser automation can still fail when the page, data, timing, or test environment changes.

When to use the command-line runner or WebDriver code

IDE playback is suited to quick browser-level capture and replay. If you need a code-based workflow, or execution beyond the IDE’s browser window, Selenium’s documentation points to two routes:

Command-line runner: use the runner when you need additional browser execution. Check the current runner documentation and browser compatibility before relying on a particular browser or version combination.
WebDriver code export: the IDE documentation describes right-clicking a test or suite, selecting Export, choosing a target language, and exporting a file. The export page lists C# NUnit, Java JUnit, JavaScript Mocha, and Python pytest. That page is dated, so treat the list as what the page documents, not a guarantee of current support. Check the export menu and current release notes before building a workflow around a target.

WebDriver is Selenium’s language-neutral interface for controlling browsers. IDE can be a starting point for learning commands; exported code gives you a code-based artifact to inspect and develop further. The official pages do not provide a current quantitative benchmark between these paths. See Selenium WebDriver getting started, command-line runner documentation, and the code export guide.

Or skip the browser setup

If your goal is to capture a page image or PDF rather than replay browser interactions, ScreenshotNeo provides a website screenshot API and MCP server. One GET request returns a PNG, JPEG, WebP, or PDF. See the ScreenshotNeo API documentation for request options.

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

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

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);

Cookie banners are accepted like a visitor and removed before the shot, along with 60+ known consent platforms, newsletter popups, and chat widgets; each step can be turned off. Bot checks and CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing, and response headers say whether the page was clean and billed. Its MCP server gives AI agents tools to take screenshots, get page information, and capture PDFs. The free plan includes 1,000 screenshots per month with no card; paid plans start at $5 for 3,000, and every feature is on every plan.

Troubleshooting Selenium IDE recording and playback

Symptom	Likely cause	What to try
The IDE does not open the application window.	The recording flow was not started, the browser blocked or interrupted the new window, or the extension is unavailable in that browser profile.	Start the record flow again, check the browser’s extension menu and permissions, and confirm the extension is installed in the profile you are using.
The recording misses an action.	The action may have happened outside the window Selenium IDE opened, or recording may have been stopped.	Confirm recording is active, repeat the action in the IDE-managed window, then inspect the command list before saving.
Playback opens a new window.	The original recording window is no longer open.	This is expected IDE behavior; playback opens a new window if the recording window has been closed.
A test fails on replay at a recorded target.	The page may have changed, the target may no longer identify the intended element, or the test data/state may differ.	Inspect the failed command and target, reproduce the workflow with known test data, and update the command or recording to match the current page.
The project changes are missing after reopening.	The latest edits may not have been saved to the `.side` file.	Save the project after recording or editing, then reopen the saved file and confirm the expected test appears.
An export language or runner option is absent.	Documented export targets and runner capabilities can change across IDE releases.	Check the export menu in the installed IDE and the current Selenium IDE release notes and runner documentation before choosing a target.

Performance, reliability, and cost

Selenium IDE’s record-and-replay flow runs through a browser, so replay time depends on the page and workflow being exercised. The reviewed official material does not publish a playback benchmark. For more repeatable runs, keep test data and application state predictable, and inspect failed commands rather than rerunning blindly.

The IDE getting-started guide describes saving a project as a local .side file. The cited pages do not specify a Selenium IDE subscription price or a service-level guarantee; check the current official pages for applicable distribution and runner details. If you need a hosted screenshot capture instead of interactive browser testing, ScreenshotNeo bills only clean shots and exposes the page verdict and billing status in response headers; its listed plans and options are described in the documentation.

FAQ

Does Selenium IDE test an entire application automatically?

No. It records and replays the workflows you create. You choose which tests to record, what outcomes to check, and when to run them.

Can I edit a recorded test?

Yes. Selenium IDE supports entering commands manually as well as recording interactions, so you can review and adjust the recorded steps in the editor.

Is a screenshot API a replacement for Selenium IDE?

No. Selenium IDE replays browser interactions as tests. A screenshot API captures a page image or PDF; it does not provide the same recorded interaction workflow.