13 Best Selenium Alternatives for Test Automation in 2026

The Selenium alternatives worth your time in 2026 do two different jobs. Code-first frameworks (Playwright, Cypress, WebdriverIO, TestCafe, Nightwatch, Puppeteer) are where your engineers write tests. AI and low-code platforms (Katalon, testRigor, mabl, Testim, Momentic, Qodex, Panto) are where somebody or something else writes them. Device clouds are a third thing: they run whatever you already wrote, Selenium included. Every price and license below came off the vendor's own page on 29 August 2026, Nightwatch on 30 August. Where a vendor publishes no number, this guide says so instead of guessing. You can also see how Qodex compares to every major QA tool.

Quick answer by job

• Cross-browser tests, more than one language: Playwright. Apache 2.0, three engines, bindings beyond JavaScript.

• JavaScript frontend, fast feedback: Cypress. The app is MIT; Cloud Team is $67 a month billed annually.

• Keep WebDriver and the Grid: WebdriverIO or Nightwatch. Both MIT, both speak W3C WebDriver.

• Least setup: TestCafe. MIT, no driver binaries, one flag for concurrency.

• Driving Chrome rather than testing: Puppeteer. Apache 2.0 library, bring your own runner.

• A Python, Java or .NET suite: Playwright is the only tool here publishing bindings for all three.

• Tests in plain English: testRigor. Free public plan, private from $300 a month on Linux Chrome.

• Importing an existing suite: mabl. Its CLI is the only importer here that reads Java, Python, .NET and Protractor.

• Nobody has time to write tests: Qodex or Momentic. Both generate tests rather than give you a better place to type them.

• Real phones: Panto publishes 150+ real device and OS combinations, or run any framework on a device cloud. See our BrowserStack alternatives guide.

• Staying on Selenium: often the right answer. The stay-put case is below.

Six of those cost nothing to license and one starts at $1,299 a month. That gap is the point: "Selenium alternative" hides two questions, a better framework to write tests in, or fewer tests written by hand at all.

What kind of Selenium replacement do you need?

Selenium is three things at once, which is why replacing it gets confusing. It is an API you write tests against, a protocol browsers implement, and a Grid you run them on. Different products replace different parts.

A code-first framework replaces the API. You still write every test and own the repository; the win is auto-waiting, a bundled runner and a real debugger. Playwright, Cypress, WebdriverIO, TestCafe, Nightwatch and Puppeteer.

An AI or low-code platform replaces the author. Tests live in the vendor's product as plain English, recorded steps or generated code, and the pitch is that maintenance stops being your job. Katalon, testRigor, mabl, Testim, Momentic, Qodex and Panto.

Execution infrastructure replaces neither. BrowserStack, Sauce Labs and a self-hosted Grid rent you browsers and devices. They are a column in the decision, not a competitor to Playwright.

Scraping tools are a fourth category that shows up in the same search results. There is a short section on them near the end.

When to keep Selenium

Your suite is in a language nobody else supports. Playwright publishes JavaScript, TypeScript, Python, Java and .NET bindings. Every other framework here is JavaScript and TypeScript only. If your tests are Ruby, PHP or Kotlin, there is nothing on this page to move them to.

Your infrastructure already works. WebdriverIO, Nightwatch and Testim all still talk to Selenium-compatible grids, and mabl's importer reads from Grid, Sauce Labs and BrowserStack. That compatibility exists because Selenium's protocol became the standard.

Nothing imports your test code. Only two products here publish a path for existing Selenium code, and both are partial: Katalon copies Selenium 4.x, TestNG and JUnit code into a project, mabl's CLI carries navigation and clicks. Everywhere else, migration means rewriting.

The pain is not the framework. If your failures come from test data, environments or nobody having time to write coverage, a new API fixes none of it.

Move when you can name the thing that will get better. "Selenium is old" is not that thing.

Selenium alternatives at a glance

Checked 29 August 2026, Nightwatch on 30 August. "Not published" means the vendor's page did not state it that day, not that the feature is missing.

Code-first framework profiles

These replace the API you write against. You keep the repository, the review process and the maintenance bill.

1. Playwright

Playwright is Microsoft's open-source framework and the default landing spot for teams leaving Selenium.

• License: Apache 2.0. No paid vendor plan, no meter.

• Languages and browsers: JavaScript, TypeScript, Python, Java, .NET. Chromium, Firefox and WebKit, plus branded Chrome and Edge. Not branded Safari.

• Parallel and hosting: files run in parallel by default and shard across machines. Local or CI.

• Migration from Selenium: no importer in the docs checked. The API and execution model mean a rewrite.

• CI and AI: examples for GitHub Actions, GitLab, Bitbucket and Jenkins. The home page also positions Playwright for AI agents, with accessibility snapshots and an MCP server.

Best for: most teams leaving Selenium, mixed-language ones especially. See Playwright alternatives and Playwright vs Cypress.

Watch out for: WebKit is not Safari, and a person still writes and maintains every test.

2. Cypress

Cypress runs inside the browser instead of driving it from outside, and publishes the most detailed migration guide on this page.

• License: Cypress App is MIT. Cypress Cloud is a separate paid product.

• Price, 29 Aug 2026: Cloud Team from $67 a month billed annually at $799. Business from $267 a month annual.

• Free: Starter covers 50 users, 500 test results a month, 100 prompt executions, 30-day retention.

• Languages and browsers: JavaScript and TypeScript only. It bundles Electron and otherwise uses the browsers on your machine.

• Parallel and hosting: cloud parallelization is included, metered by test results rather than seats. Self-hosting the Cloud is not published.

• Migration from Selenium: a first-party guide updated 24 August 2026 maps lifecycle, waits, locators, assertions, frames, authentication and CI. Java, Python, C# and Ruby suites get rewritten in JavaScript, and it recommends running both frameworks side by side while you do.

Best for: JavaScript teams where debugging speed beats browser breadth. See Cypress alternatives.

Watch out for: one language, and a big suite meets the results meter fast.

3. WebdriverIO

WebdriverIO is the smallest infrastructure change here: a modern Node.js framework around the protocol you already run.

• License: MIT. No paid vendor plan.

• Languages and browsers: JavaScript and TypeScript. It drives browsers over W3C WebDriver, or Chromium through Chrome DevTools via Puppeteer. Appium adds native mobile.

• Parallel and hosting: spec files run in isolated workers, maxInstances sets concurrency. Local, CI, Selenium Grid or a commercial grid.

• Migration from Selenium: no importer, but capabilities, page objects, Grid and cloud setup keep their shape, so less changes around the tests than a Cypress or Playwright move.

• CI and AI: headless when the CI environment flag is set. No first-party AI authoring or healing in the docs checked.

Best for: teams with a Grid, a cloud contract or Appium tests to keep. See Selenium vs WebdriverIO.

Watch out for: more configuration than Playwright, and a JavaScript rewrite is still a rewrite.

4. TestCafe

TestCafe, from DevExpress, skips WebDriver entirely. No driver binaries, no plugins, no Grid.

• License: MIT for the framework. TestCafe Studio is a separate commercial IDE, with no current amount in the sources checked.

• Languages and browsers: JavaScript and TypeScript. Modern Chromium, Chrome, Edge, Firefox, Opera and Safari, plus headless, remote, mobile and cloud browsers. No IE 11 or legacy Edge.

• Parallel and hosting: a concurrency flag launches several instances per named browser. Local, remote or cloud browsers.

• Migration from Selenium: no importer and no WebDriver, so the tests and the way they run both change.

• CI and AI: runs from its CLI in CI. No first-party AI for the open-source framework.

Best for: small JavaScript teams who want to be running tests an hour after deciding to.

Watch out for: a smaller ecosystem, and the paid Studio IDE has no published price to plan around.

5. Nightwatch

Nightwatch is the other WebDriver-native option, built at BrowserStack, with one runner for end-to-end, component, accessibility, API and mobile tests. Version 3.16.0 was current on 30 August 2026.

• License: MIT, in the LICENSE file on the official repository. No paid vendor plan.

• Languages and browsers: JavaScript and TypeScript on Node.js, over the W3C WebDriver API. The docs cover ChromeDriver, GeckoDriver, SafariDriver and EdgeDriver, plus native mobile through Appium.

• Parallel and hosting: parallel running is documented. Local, a Selenium server, CI, or a cloud provider.

• Migration from Selenium: no importer. Your Grid and cloud endpoints keep working, the test code becomes JavaScript.

• CI and AI: guides for Jenkins, GitHub Actions, Bamboo, Azure Pipelines, CircleCI and GitLab CI. No first-party AI authoring is published.

Best for: WebDriver teams who want component and accessibility coverage in the same runner as end-to-end.

Watch out for: it inherits WebDriver's round trips, so the speed argument for leaving Selenium mostly does not apply.

6. Puppeteer

Puppeteer is a browser-control library from the Chrome team, not a test framework. That distinction decides whether it belongs on your shortlist.

• License: Apache 2.0. No paid vendor plan.

• Languages and browsers: JavaScript and TypeScript. Official support is Chrome for Testing and stable Firefox. No WebKit or Safari.

• Parallel and hosting: no test runner, so parallelism comes from whatever you pair it with. Local or CI.

• Migration from Selenium: no importer. Tests get rewritten against Puppeteer's API, and you assemble the runner, assertions and reporting yourself, exactly as with Selenium.

• CI and AI: official CI guidance. No first-party AI in the product docs checked.

Best for: Chrome automation, screenshots, PDFs and page instrumentation.

Watch out for: if what you dislike about Selenium is assembling a stack, this hands you the same job.

Cucumber sits on top, not instead

Official implementations cover JavaScript, Java, Kotlin, Scala, Ruby, Android Java and C++, with current repositories such as Cucumber-JVM under MIT and no paid plan. It is a specification and runner layer, not a browser driver: the browser comes from Selenium, Playwright, WebdriverIO or another adapter. Parallel behaviour depends on the implementation, and Cucumber-JVM has built-in multithreaded execution. Change frameworks and the Gherkin scenarios can stay while the step definitions underneath get rewritten.

AI and low-code platform profiles

These replace the author rather than the API. The trade is the same in all seven: less code to maintain, less control over what runs, and a bill.

7. Katalon

Katalon is a low-code platform built over Selenium and Appium, which gives it the most literal migration story here.

• License: no platform open-source license is published.

• Price, 29 Aug 2026: Studio is $180 per seat per month monthly. On annual billing the first three seats are $84 and later seats $150. True Automation is $167 per seat per month annual.

• Free: a 30-day trial with five True Automation seats, five Runtime Engine licenses, three cloud sessions, five admin seats, unlimited viewers.

• Authoring and coverage: low-code with Groovy and Java extensions. Web on Chrome, Firefox, Safari and Edge, plus Android, iOS, APIs and Windows desktop.

• Parallel and hosting: parallel execution included, one cloud session per five True seats, extra cross-browser sessions $197 a month or $1,899 a year. Enterprise offers hybrid offline licenses and managed private SaaS, not a control plane you run.

• Migration from Selenium: the docs support copying Selenium 4.x, TestNG 6.11 and JUnit 4.12 code into a project, with Selenium dependencies bundled. Code migration, not lossless conversion.

• CI and AI: Runtime Engine runs from the CLI in named CI systems. AI agents cover generation, failure analysis and self-healing.

Best for: QA teams with a Java or TestNG suite and manual testers who need somewhere to work. See Katalon alternatives.

Watch out for: per-seat pricing that grows with the team, and cloud sessions priced apart from seats.

8. testRigor

testRigor replaces selectors with plain English steps, so anyone who knows the product can read a test.

• License: the platform is not published as open source.

• Price, 29 Aug 2026: Private Linux Chrome from $300 a month. Private Complete has a 14-day trial, Enterprise is custom.

• Free: the public plan gives one user and unlimited tests, on the condition that your tests and results stay public under the Unlicense.

• Authoring and coverage: plain English across web, mobile, API, Windows native and mainframe. The $300 plan is limited to Linux Chrome.

• Parallel and hosting: parallel by default, priced by execution infrastructure rather than users or runs. Enterprise publishes an on-premise option.

• Migration from Selenium: no importer. You recreate tests as plain English rather than port them.

• CI and AI: CLI integration for CI on the free plan. Private plans publish AI test generation and execution.

Best for: teams where the people who know what to test do not write code.

Watch out for: free means public. If your steps describe an unreleased flow, the free plan is out.

9. mabl

mabl is the only tool here with a published Selenium importer, and the limits of that importer are worth reading closely.

• License: not published.

• Price, 29 Aug 2026: quote-based, no amount published. A 14-day trial is available.

• Free: no free plan. Plans start with 500 cloud-run credits a month, while local and CI runs, participant licenses, applications, environments, workspaces and cloud concurrency are unlimited.

• Authoring and coverage: low-code web, mobile and API testing. The pricing page publishes no desktop-browser list.

• Parallel and hosting: unlimited local, CI and cloud runs. A local runner exists; full self-hosting is not published.

• Migration from Selenium: the CLI imports from Java, Protractor, .NET and Python, and from local or remote WebDriver, Grid, Sauce Labs and BrowserStack. It carries viewport, navigation, text entry and clicks. Assertions, variables, loops, conditions, files, frames, hover and cookies get rebuilt.

• CI and AI: CLI and CI/CD integrations, with autonomous build and maintenance, auto-healing, runtime recovery and root-cause insights.

Best for: teams with a large Selenium suite who want the navigation skeleton lifted across rather than retyped.

Watch out for: the importer moves the easy half. Assertions encode what the product is supposed to do, and those you rebuild.

10. Testim

Testim records low-code tests with optional JavaScript, and is unusually flexible about where they run.

• License: not published.

• Price, 29 Aug 2026: no stable list price is published.

• Free: the current account guide publishes up to 1,000 runs a month, plus a seven-day trial.

• Authoring and coverage: low-code recording with optional JavaScript. Local runs use Chrome; remote grids add Firefox, Safari and Edge Chromium.

• Parallel and hosting: a CLI flag sets concurrent tests, on Testim Grid, a third-party grid or your own Selenium-compatible grid. Platform self-hosting is not published.

• Migration from Selenium: no test importer published. Pointing it at your grid reuses the infrastructure and converts none of the code.

• CI and AI: CLI integration for CI, with natural-language authoring, smart locators, self-healing and failure analysis.

Best for: teams that want recorded tests but refuse to give up their own grid.

Watch out for: no published price means the budget conversation happens before the evaluation.

11. Momentic

Momentic writes tests from natural language or YAML and prices them in credits rather than seats.

• License: not published.

• Price, 29 Aug 2026: pay-as-you-go is $125 a month plus usage, with 10,000 credits, about 1,000 runs.

• Free: 2,000 credits a month, about 200 runs, plus 30 mobile-emulator minutes, one concurrent emulator, 30-day retention.

• Authoring and coverage: natural language and YAML. Web on Chromium-based browsers, mobile on local or hosted iOS simulators and Android emulators, with no real-device inventory published.

• Parallel and hosting: your machines, CI or Momentic's infrastructure. Paid includes five concurrent Android and five iOS emulators. Full self-hosting is not published.

• Migration from Selenium: no importer. Tests are recreated in natural language or YAML.

• CI and AI: CLI examples for GitHub Actions, CircleCI and Bitrise. The AI turns prompts into steps, heals locators, performs goal-based actions and records its reasoning.

Best for: product teams who want plain-English web coverage fast, with a free tier big enough to judge it.

Watch out for: credits are the meter, so a flaky suite costs more every week until someone fixes it.

12. Qodex

Qodex is an AI QA agent that writes and runs API, UI and security tests on every pull request, from your spec and your running app. UI runs happen on Playwright browsers. It is not a framework you write tests in, and it is not a device farm.

• License: not published.

• Price, 29 Aug 2026: Startup from $1,299 per project per month, with 200 scenarios, 10,000 runs and two concurrent runs. Scale from $2,500 per project per month. See Qodex pricing.

• Free: Individual is $0 with 25 scenarios, 100 runs a month, one repository, one AI chat session, one run at a time.

• Authoring and coverage: you describe the flow in chat and the agent generates the scenario. Tests export as standard Playwright and HTTP code. No language or browser-engine matrix is published beyond that.

• Parallel and hosting: one run at a time on Individual, two on Startup, custom on Scale. Self-hosting is published for PR Review Enterprise, not for automation testing.

• Migration from Selenium: no importer and no WebDriver compatibility claim. The agent writes new tests against the running app instead of translating old ones.

• CI and AI: CI/CD integrations, schedules and webhooks from Startup. AI covers generation, failure classification, maintenance, security testing and code review.

Best for: teams whose Selenium suite is expensive to keep alive rather than wrong, and teams whose incidents come from API contract breaks. See API testing, or start free against staging.

Watch out for: free to $1,299 is a steep step and the unit is the project, not the seat. To hand-write every selector, use Playwright.

13. Panto

Panto ranks for this search with its own comparison article, but the product is now mobile-first, so read it as a mobile testing platform.

• License: not published.

• Price, 29 Aug 2026: no list price and no numeric free limit. The site offers a trial and a sales contact.

• Authoring and coverage: no-code natural language for Android and iOS across 150+ real device and OS combinations. No desktop-browser or language matrix is published.

• Parallel and hosting: tests run on Panto's real-device farm. A parallel limit and a customer-hosted option are not published.

• Migration from Selenium: its FAQ says it uses a proprietary framework and does not rely on Playwright, Appium or Selenium, so nothing carries over.

• CI and AI: CI/CD, pull request, Slack, webhook and API triggers. AI agents crawl workflows, generate tests, diagnose failures and self-heal.

Best for: mobile app teams who want real hardware coverage without writing Appium.

Watch out for: nothing about price is published, and a Selenium web suite has no path into it.

Free versus open source

Two different claims, mixed constantly. Open source is about the license on the code: you can read it, fork it, and nobody can change the terms on the copy you have. Free is the price of a plan, and a plan can change next quarter.

Open source, license confirmed: Playwright and Puppeteer are Apache 2.0. WebdriverIO, TestCafe and Nightwatch are MIT, as are the Cypress App and the current Cucumber-JVM repository. Six frameworks, no meter, no seat count. Your cost is machines and engineering time.

Proprietary with a free plan: Qodex Individual is $0 with 25 scenarios and 100 runs a month. Momentic gives 2,000 credits, roughly 200 runs. Testim publishes up to 1,000 runs a month. Cypress Cloud Starter allows 500 test results across 50 users. Real ceilings, set by the vendor.

Free with a condition: testRigor's public plan is unlimited tests for one user, and in exchange your tests and results are public under the Unlicense. That is a license on your test artifacts, not on their platform.

Trials only: Katalon runs 30 days with five seats and three cloud sessions. mabl and testRigor Private Complete run 14 days, Testim seven. Panto publishes no free limit at all.

Selenium migration matrix

"Can I convert my suite?" has three different answers, and only one of them involves a tool doing the work.

Two things worth saying out loud. Cypress recommends running both frameworks side by side during the move, which is the advice that protects you whichever tool you pick. And an importer that carries clicks and navigation but not assertions has moved the typing, not the thinking.

Three small code mappings

Most of a Selenium test is waiting, finding and asserting. Here is what those three become, in Python for Selenium and Playwright.

Waiting. Selenium makes synchronization your job. The others fold it into the assertion.

# Selenium, Python
WebDriverWait(driver, 10).until(
    EC.visibility_of_element_located((By.CSS_SELECTOR, "#cart"))
)

# Playwright, Python: the assertion does the waiting
expect(page.locator("#cart")).to_be_visible()

// Cypress: the command retries until it passes or times out
cy.get('#cart').should('be.visible')

Finding and clicking. The shift is from CSS selectors to what the user sees, which is what survives a redesign.

# Selenium, Python
driver.find_element(By.CSS_SELECTOR, "button.checkout").click()

# Playwright, Python
page.get_by_role("button", name="Checkout").click()

// Cypress
cy.contains('button', 'Checkout').click()

Asserting. Selenium hands you a value and your test framework checks it. Playwright and Cypress retry the check.

# Selenium, Python
assert driver.find_element(By.CSS_SELECTOR, "h1").text == "Order confirmed"

# Playwright, Python
expect(page.locator("h1")).to_have_text("Order confirmed")

// Cypress
cy.get('h1').should('have.text', 'Order confirmed')

Line by line the translation is mechanical. What is not mechanical is everything around it: fixtures, test data, custom waits somebody wrote in 2021, and the helper library your team built on WebDriver. Budget for that, not for the three lines above.

Where tests run

Authoring and execution are separate decisions, and mixing them up is how a device cloud ends up on a shortlist against Playwright.

Local machines. Every framework here runs on a laptop, and mabl and Momentic both publish local runners.

Your CI. The normal home for a suite. All six frameworks publish CI guidance, and the platforms hook in through a CLI: Katalon's Runtime Engine, testRigor's CLI on the free plan, Momentic's GitHub Actions, CircleCI and Bitrise examples, Qodex from Startup upward.

A Selenium Grid you run. Still the answer when nothing may leave your network. WebdriverIO, Nightwatch and Testim all connect to it, and mabl reads from it during an import.

A commercial device cloud. BrowserStack, Sauce Labs and the rest rent browsers and real phones. They write nothing, and they run Selenium and its alternatives equally well, which is why they are infrastructure rather than a replacement. See BrowserStack alternatives.

A vendor's own cloud. Katalon meters cloud sessions, testRigor prices by execution infrastructure, mabl by cloud-run credits, Momentic by credits and emulator minutes, Panto by its device farm, Qodex by runs per project. Cheapest to start, and the meter is the thing to model before you commit a suite.

Looking for a Selenium alternative for scraping?

Different job, same search box. Selenium, Playwright and Puppeteer are browser libraries: they drive a real browser and hand you a DOM, which is what you want for testing and for scraping sites that need a session. Scraping and browser-infrastructure products such as Firecrawl, ZenRows and Browserbase sit a layer up and return extracted content or a hosted browser instead. If your goal is data rather than a green build, this is the wrong list, and the short answer is Playwright or Puppeteer when you need the browser, a scraping API when you only need the page.

How to choose

Five questions. Each has two answers, and the pair usually eliminates most of this page.

Count maintenance hours, not license fees. Six of these frameworks cost nothing and still cost a day a week of somebody's time. That is the number the platforms compete with.

Check the exit before you commit a suite. Framework tests are portable by definition and Qodex exports Playwright and HTTP code. Recorded and plain-English tests live in the vendor's platform, so ask what leaves with you.

Frequently Asked Questions

Is Selenium dead in 2026?

No, and the alternatives are the evidence. WebdriverIO, Nightwatch and Testim all still run on Selenium-compatible grids, Katalon bundles the Selenium dependencies, and mabl's importer reads from Grid, Sauce Labs and BrowserStack. What has changed is that fewer teams start new suites with it.

What is the best free alternative to Selenium?

Playwright, for most teams: Apache 2.0, bindings for JavaScript, Python, Java and .NET, three engines, parallel runs by default, no meter. To keep WebDriver, WebdriverIO and Nightwatch are both MIT. TestCafe is MIT with the least setup, Puppeteer is Apache 2.0 for Chrome work, and the Cypress App is MIT though its parallelization lives in the paid Cloud.

Is Playwright better than Selenium?

For a new suite, usually. It bundles the runner, assertions, parallel execution and tracing that Selenium expects you to assemble, and it auto-waits. Selenium keeps two advantages: your existing code runs today, and it covers languages Playwright publishes no bindings for. If your tests are Ruby, PHP or Kotlin, this is not a migration, it is a rewrite in a new language.

Can I automatically convert my Selenium tests to another framework?

Partly, in two products. mabl's CLI imports from Java, Python, .NET, Protractor, WebDriver, Grid, Sauce Labs and BrowserStack, carrying viewport, navigation, text entry and clicks; assertions, loops, conditions, frames and cookies get rebuilt. Katalon lets you copy Selenium 4.x, TestNG 6.11 and JUnit 4.12 code into a project. Everywhere else migration means rewriting, and Cypress publishes a guide for doing exactly that.

What is the best Selenium alternative for Python?

Playwright. It is the only tool here publishing Python bindings, and its Python API maps cleanly onto what a Selenium test already does. If you would rather not rewrite, mabl's importer reads Python Selenium tests, though it carries only navigation and clicks.

Do I need to know JavaScript to move off Selenium?

No. Playwright publishes Python, Java and .NET bindings, Katalon is low-code with Groovy and Java extensions, testRigor is plain English, Momentic takes natural language or YAML. But Cypress, WebdriverIO, TestCafe, Nightwatch and Puppeteer are JavaScript and TypeScript only, so five of the six frameworks here do require it.

What is the best no-code or Selenium IDE alternative?

testRigor if tests should read like sentences, with a free public plan for one user. Katalon if you want an IDE with record and playback plus reporting. Testim publishes up to 1,000 runs a month free, Momentic about 200. The catch on testRigor's free plan is that your tests and results are public.

Which alternatives keep my Selenium Grid?

WebdriverIO and Nightwatch drive browsers over W3C WebDriver, so a Grid, Sauce Labs or BrowserStack endpoint keeps working. Testim runs on your own Selenium-compatible grid, and mabl reads from Grid and the clouds during an import. Playwright, Cypress, TestCafe and Puppeteer do not use WebDriver, so the Grid goes when they arrive.

Which Selenium alternative handles mobile as well as web?

WebdriverIO with Appium is the code-first answer, and Nightwatch documents Appium too. Among platforms, Katalon covers Android and iOS alongside web, API and Windows desktop, testRigor covers web, mobile, API, Windows native and mainframe, mabl covers web, mobile and API. Momentic runs simulators and emulators rather than hardware, and Panto publishes 150+ real device and OS combinations.

What should I use instead of Selenium for scraping?

Playwright or Puppeteer if you need a real browser session, since both are free and both do the job Selenium was doing. If you only want the content of a page, a scraping API returns extracted data without you running a browser at all. Different product category, and a testing guide is the wrong place to pick one.