Recommended Free Tools
SeleniumBase is a Python framework that keeps Selenium’s browser control while adding a test-oriented workflow, smart waiting, reports, headless execution, and parallel-run support. Install it with pip install seleniumbase, write tests with its BaseCase class, and run them with pytest. Use UC Mode or CDP Mode only when a project specifically needs their alternate browser-control behavior; ordinary SeleniumBase tests do not require either mode.
What SeleniumBase adds to Selenium
SeleniumBase describes itself as “A powerful Python framework for browser automation and E2E UI testing.” It is built for Python projects and can work with pytest, unittest, nose, and behave. The framework keeps familiar browser automation concepts—URLs, locators, clicks, typing, assertions—but supplies more test structure and operational tooling around them.
- Test-runner integration: pytest is the usual starting point, with unittest, nose, and behave support also documented.
- Smart waiting: common actions and assertions can wait for page conditions instead of requiring a fixed sleep everywhere. This reduces timing mistakes, but it cannot make every test or application deterministic.
- Logging and reports: test activity and results can be inspected after a run, which is useful in local debugging and CI.
- Headless execution: browsers can run without a visible window for CI or server environments.
- Parallel browser execution: independent tests can be distributed across browser processes when your suite and environment support it.
These conveniences are most valuable when Selenium is being used as a repeatable test suite rather than as a one-off script. The official feature list is the reference for the currently supported integrations and options.
Install SeleniumBase in an isolated Python environment
Use the Python environment selected for your project. The official installation guide documents the package install, Git checkout, and editable development installation.
The Tool Desk
Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →#1 Best Overall
- Create and activate a virtual environment (the exact activation command depends on your operating system).
- Install the package:
python -m pip install seleniumbaseThe shorter command shown in the official guide is also valid:
pip install seleniumbase- Check that the command-line entry point is available:
seleniumbase --helpFor contributor work or when you need to modify SeleniumBase itself, follow the Git and editable-mode instructions on the installation page. Browser-driver management and browser-version requirements can change, so consult that live page when setting up a new machine or CI image.
Your first SeleniumBase test
Create test_example.py:
from seleniumbase import BaseCase
class TestExample(BaseCase):
def test_home_page(self):
self.open("https://example.com")
self.assert_title_contains("Example Domain")
self.assert_text("Example Domain", "h1")
Run it from the directory containing the file:
pytest -q test_example.pyBaseCase supplies the test setup and browser-aware methods. self.open() navigates to the URL, while the assertion methods fail the test with useful context when the expected title or text is absent. CSS selectors such as h1 are simple and readable; for application tests, prefer stable attributes that your team controls (for example, a dedicated data-testid) over selectors tied to layout or generated class names.
A form interaction
The same style applies to controls and assertions. This example uses selectors that would need to match the actual application under test:
Free tools Windows power users keep installed
One-click scans. No signup required.
from seleniumbase import BaseCase
class TestLogin(BaseCase):
def test_login_form(self):
self.open("https://app.example.test/login")
self.type("input[name='email']", "[email protected]")
self.type("input[name='password']", "correct-horse-battery-staple")
self.click("button[type='submit']")
self.assert_element("[data-testid='account-home']")
Do not put real credentials in source control. Use your CI secret store or environment variables and make the test account safe to reset.
Use smart waiting without hiding real failures
Browser pages are asynchronous: a button may exist in the DOM before it is visible, and a results panel may appear after an API response. SeleniumBase’s higher-level actions and assertions include waiting behavior intended for these normal transitions. That is preferable to sprinkling arbitrary time.sleep() calls through every test.
Rank #2
Waiting still needs a clear condition. If an application never renders the selector, a smart wait should eventually fail rather than make the suite pass. Keep waits bounded, assert the state that matters, and investigate slow or inconsistent tests instead of raising timeouts indefinitely. For unusual timing, SeleniumBase also provides explicit waiting APIs documented in its usage and API references.
Example: wait for a result, then assert its content
from seleniumbase import BaseCase
class TestSearch(BaseCase):
def test_search_result(self):
self.open("https://app.example.test/search")
self.type("input[name='q']", "seleniumbase")
self.click("button[type='submit']")
self.wait_for_element("[data-testid='results']")
self.assert_text("seleniumbase", "[data-testid='results']")
Use the application’s meaningful state as the synchronization point. A fixed delay can be too short on a busy runner and unnecessarily slow on a fast one.
Run headless, collect diagnostics, and scale runs
Headless execution
Headless mode is useful on CI agents without a desktop. SeleniumBase exposes command-line options for browser and display behavior; run seleniumbase --help and consult the documentation table of contents for the current flag names and examples. Keep one visible-browser run available when diagnosing layout or focus problems, because headless rendering can expose environment-specific differences.
Reports and logs
Use the test output and SeleniumBase reporting options to identify the failing URL, selector, and step. Preserve artifacts such as screenshots, page source, and browser logs in CI when a failure is difficult to reproduce. The available report format and command-line switches depend on the installed version; use the project’s usage examples and API reference rather than copying an old flag from an unrelated Selenium tutorial.
Parallel execution
Parallelism shortens suites when tests are independent. Before enabling it, ensure each test has isolated data, does not depend on another test’s browser state, and can run against a service that tolerates concurrent requests. Shared accounts, mutable records, rate limits, and a single fixed download directory are common sources of false failures. Start with a small worker count and increase it only after the suite is stable.
Choosing a test structure: class-based tests or a context manager
The class-based BaseCase pattern is the normal SeleniumBase test workflow because pytest discovers the class and the framework controls setup and teardown:
from seleniumbase import BaseCase
class TestCheckout(BaseCase):
def test_guest_checkout(self):
self.open("https://shop.example.test")
# browser actions and assertions here
For a small script or a flow that does not fit a pytest class, SeleniumBase also documents a context-manager style. The context manager owns the browser lifetime:
from seleniumbase import SB
with SB() as sb:
sb.open("https://example.com")
sb.assert_title_contains("Example Domain")
Choose one style for a given piece of code. A frequent setup error is trying to use instance methods such as self.open() in a function that was created with SB(), or trying to access a context-managed object after its with block has ended. If your question resembles “How can I use seleniumbase in __init__ instead of contextmanager,” first decide whether the code is a pytest test (use BaseCase) or an independent automation script (use SB), then keep browser creation and cleanup in that same lifecycle.
When UC Mode is appropriate
UC Mode is based on undetected-chromedriver and adds SeleniumBase updates plus special uc_* methods. It is a specialized mode, not a prerequisite for normal UI tests. Use it only when the project’s current documentation and your site’s access policy support that choice.
The UC Mode guide contains the supported setup and examples. Do not interpret the mode as a guarantee of access to every site or anti-bot system, and do not use automation to bypass an operator’s access controls. Obtain permission and respect terms, robots policies, and applicable law.
Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minutePC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11CDP Mode and its relationship to UC Mode
SeleniumBase’s CDP examples describe two related approaches: a CDP subset activated from UC Mode and a pure CDP mode. CDP (Chrome DevTools Protocol) uses a different interaction API from ordinary WebDriver calls. In the documented flow, WebDriver can be disconnected while CDP methods operate; reconnecting restores WebDriver-only methods.
The project warns that reconnecting can make anti-bot detection possible. Treat that as SeleniumBase’s own guidance, not as a universal detection rule or a promise that disconnecting defeats a particular service. Mode-specific APIs and behavior can change, so start with the current CDP examples and README.
Practical decision rule
- Use ordinary
BaseCaseorSBfor standard functional and regression tests. - Evaluate UC Mode when the project explicitly needs its undetected-chromedriver-based workflow and the target permits it.
- Evaluate CDP Mode when you need the documented CDP interaction model or want to work temporarily without WebDriver, then reconnect only when a WebDriver-only operation is required.
Or skip the browser setup
If your goal is a clean image of a page rather than an interactive test, ScreenshotNeo provides a website screenshot API and MCP server. It accepts consent banners before capture and removes more than 60 known consent platforms, newsletter popups, and chat widgets; each cleanup step can be disabled. Only clean shots are billed: bot checks or CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing, and the response reports the result in X-Page-Verdict and X-Billed headers.
One GET request returns PNG, JPEG, WebP, or a PDF:
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpSee the ScreenshotNeo API documentation for all options. The service also supports full-page capture with lazy images loaded, CSS-selector element shots, dark mode, device presets and custom viewports, retina scale, PDF paper settings and page ranges, custom CSS and JavaScript, clicks, selector/delay/network-idle waits, request blocking, headers, cookies, user agents, authorization, timezone and geolocation, transparent backgrounds, resizing, chosen cache TTLs, signed image links, asynchronous signed webhooks, bulk capture of up to 100 URLs per call, usage data, and an OpenAPI specification. An MCP server exposes take_screenshot, get_page_info, and capture_pdf to Claude, Cursor, and other MCP clients.
Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Repair Windows errors before they cause bigger problemsFix Now →The Free plan includes 1,000 shots per month with no card. Paid plans start at $5 for 3,000 shots; every feature is included on every plan, and yearly billing provides two months free. Create a free ScreenshotNeo account.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Troubleshooting common failures
“No module named seleniumbase”
You installed into a different Python environment than the one running pytest. Activate the project environment and use python -m pip install seleniumbase, then run pytest from that same shell.
Browser or driver cannot start
Check the browser installed on the runner, permissions, display availability, and the current SeleniumBase installation instructions. Recreate the virtual environment if dependencies were mixed between system Python and the project environment.
Element not found or intercepted
Verify the selector in the actual page, wait for the application’s meaningful state, and check whether an overlay, consent dialog, iframe, or shadow DOM changes interaction. Replace brittle generated selectors with stable attributes where possible.
Works visibly but fails headless
Capture the failure’s logs and screenshot, compare viewport and timing, and try a visible run to identify focus or rendering assumptions. Make viewport-dependent behavior explicit rather than adding long sleeps.
Tests fail only in parallel
Look for shared accounts, records, ports, files, or server-side rate limits. Isolate test data and ensure each worker has independent temporary paths.
UC or CDP behavior differs from WebDriver
Confirm which mode created the browser and use that mode’s documented methods. Do not assume a WebDriver method is available while disconnected from WebDriver; reconnect only according to the current CDP guide.
Next references
The official documentation index links usage examples, API references, command-line guidance, CI/CD material, UC Mode, and CDP Mode. Use those pages for version-specific syntax and configuration rather than relying on copied snippets whose flags may have changed.
Frequently Asked Questions
Can SeleniumBase tests still use pytest fixtures?
Yes. SeleniumBase supports pytest-based tests; combine its documented test structure with fixtures according to pytest’s fixture and lifecycle rules.
Do I need UC Mode to run a normal SeleniumBase test?
No. Standard SeleniumBase tests use the regular framework workflow. UC Mode and CDP Mode are specialized alternatives for cases that need their distinct browser-control APIs.
Is SeleniumBase a measured replacement for every Selenium framework?
The project documents integrations and features, but the cited material does not establish a neutral benchmark or universal reliability advantage. Evaluate it against your application, browser matrix, and CI requirements.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
