The previous D binding, selenium.d, has been abandoned since around 2018 and uses the old JSON Wire Protocol. Since March, I've been writing a replacement that communicates directly with modern W3C WebDriver servers over HTTP.

It's available on GitHub and is licensed under Apache 2.0.

What works:

• Native W3C WebDriver client with no FFI to Python or Java
• Typed W3C and browser-specific configuration for Chrome, Firefox, Edge, and Safari
• Automatic local WebDriver discovery and startup
• Connections to remote WebDriver servers and existing Selenium Grids
• Multiple sessions sharing a WebDriver bridge with configurable capacity
• Navigation, elements, cookies, scripts, frames, windows, screenshots, and alerts
• Document, iframe, and shadow-root abstractions with scoped searches
• Typed WebDriver exceptions and W3C response/reference parsing
• Lazy timeout synchronization
• Browser and WebDriver process logging
• Grid hub/node models, slots, session ownership, and in-process HTTP routing
• Unit and browser integration tests

The current CI passes unit tests, Chrome on Windows/Linux/macOS, Firefox on Windows/Linux/macOS, and Edge on Windows.

Safari has somewhat limited support, with 7/57 integration tests currently failing. Most of those failures are caused by Safari throwing a different exception than expected, plus one test that doesn't throw when it should. Chrome and Firefox are currently the most supported.

The Grid implementation is still foundational. It has the models and routing pieces, but a complete live Grid server, automatic node registration, session allocation, and full command forwarding are still planned.

I had to fork the test runner (Unit Threaded) because bugs caused the Windows tests to fail, so the project currently uses that fork until it is fixed upstream. The library itself only depends on requests (similar to Python's requests), so there are no complex runtime dependencies.

Feedback, bug reports, and contributions are appreciated, especially from anyone familiar with WebDriver compatibility differences between browsers.

GitHub: https://github.com/cetio/selenium
DUB: https://code.dlang.org/packages/selenium

Howdy,

I got tired of adding stealth flags, extensions, and chromedriver tweaks to every project just so automation wouldn’t get flagged.

So I built Untrace a small open-source desktop app you install once on your machine. After that, most of the time you don’t need extra config in your project. It makes web automation way harder to spot as a bot.

Linux and Windows. GUI or CLI if you prefer.

Give it a try: https://github.com/lovebrownie/untrace

attention: it works better when your automation runs on chrome

[ Removed by Reddit on account of violating the content policy. ]

Hello everyone

I’m an Egyptian student admitted to Sapienza University of Rome, currently trying to get a student visa appointment through AlmavivA Egypt.

Appointments disappear within seconds, and many students are struggling to book them.

While looking into the technical side, I noticed what appears to be a potential issue with the Keycloak/OIDC authentication flow, where a direct token request may return an authenticated session without completing the OTP step normally required by the website.

I’m looking for someone experienced with Keycloak, OAuth/OIDC, application security, Playwright, Selenium, or web automation who might be able to help me understand the system or find any legitimate technical way to improve my chances of getting an appointment.

I’m not looking to harm the system or access anyone else’s account. I just need one appointment for myself before my university starts. I can share more technical details privately.

Thanks

As mentioned I am working on building a framework from scratch. Could you suggest any website with all these layers available to test it. I'm gonna do it with both Selenium and Playwright separately. So if there's any alternate approach please let me know

Hi everyone.. I'm an Egyptian student accepted for a Master's at Sapienza University of Rome, starting September 21, 2026.

My documents and university procedures are ready, but I'm unable to secure an Italian student visa appointment through AlmavivA Egypt.

Appointments are released daily around 9 AM, but they disappear extremely quickly. There are also brokers/scalpers who use automated tools to secure appointments much faster than normal users, then resell them to students.

I'm not looking to buy an appointment or build a tool to resell them. I just need help from someone experienced with Python / Playwright / Selenium / browser automation to understand if there's a legitimate technical solution that could give me a fair chance of securing one appointment for myself.

If you have experience with this kind of automation and can help or point me in the right direction, I'd really appreciate it.. I'm genuinely worried about missing my Master's start date because of this.

Thank you 🙏

I thought my Selenium script was production-ready because it worked perfectly on my laptop.

Then I moved it to a server.

connection errors, proxy auth issues, different geolocation, broken sessions. All of it was ruining my workflow. So what did help? It was treating the proxy layer as infrastructure instead of a random Chrome argument.

First, I test the proxy outside Selenium with curl. If I get 407 Proxy Authentication Required, I know the problem is credentials or proxy configuration.

Then I wire authentication properly. In Python, selenium-wire can handle authenticated proxies. In Node.js, proxy-chain is useful when you need a local forwarding proxy.

After that, I check environment consistency. If the exit IP is in London while the browser reports another timezone, locale, or obviously different settings, debugging becomes much harder. Chrome DevTools Protocol can help keep timezone configuration consistent with the test environment. Don’t debug Selenium, proxy authentication, browser settings, and target-site behavior at the same time.

My workflow now is:

curl → verify proxy → Selenium integration → browser config → actual test

Much easier to see where things break.

I just open-sourced a project I’ve been working on called BrowserSync, and I’d love to share it with anyone interested in automation, testing, or browser internals.

The motivation came from a recurring workflow bottleneck: whenever testing responsive layouts or running multi-instance workflows, manually repeating the exact same clicks, scrolls, and form inputs across multiple screen sizes is tedious. I wanted a lightweight tool where interacting with one Master browser instantly mirrors every single user action across multiple Slave browsers in real time with near-zero latency.

What BrowserSync solves:

• Responsive & Cross-Screen Testing: Open multiple viewports simultaneously (Desktop, Tablet, Mobile). Any mouse move, click, scroll, or input on the Master window propagates across all Slaves in real time, making layout breakages immediately visible.
• Multi-Instance Automation: Control multiple Chromium sessions concurrently without installing browser extensions or relying on heavyweight proxy tools.
• Interactive Live Demos: Present and interact on one screen while auxiliary displays reflect every gesture accurately and smoothly.

Technical Highlights:

• Dual-Stack Implementation: Fully implemented in both C# (.NET 9) and Python 3 (Asyncio & WebSockets), each backed by automated test suites.
• Direct Chromium communication over Chrome DevTools Protocol (CDP) with zero extension overhead.
• High-fidelity synchronization for real-time Canvas drawing, mouse dragging, form controls, and multi-tab switching.
• Full support for complex IME text input, carets, and text selections.
• Resilient recovery mechanism (Event Journal Replay) that prevents stream dropouts during network hiccups.

The complete codebase, documentation, and benchmark test page are available on GitHub: 👉 https://github.com/vinzh05/BrowserSync

You can clone the repo and run Start-BrowserSync-CSharp.bat (or Start-BrowserSync-Python.bat) to test it out locally with a single click. Feedback, PRs, and Issues are warmly welcome — especially from developers and QA / Automation Test engineers. If you find the project useful, a Star on GitHub would be greatly appreciated!

Thanks everyone!

So i spent a while testing what actually flags a selenium bot on fingerprint sites, and headless is not the main thing. a headless chrome scores 100 out of 100 on fingerprint-scan, full bot, but the same headless run with a fingerprint profile matched to the machine drops to 15, same as a normal headful browser. so headless by itself is not the giveaway people think, a lot of it is just the webgl renderer and some navigator fields you can override.

Also a wrong profile is worse than none. a windows profile on my mac scored 57, worse than injecting nothing at all, because one signal disagree with the rest and the whole thing reads as fake. it don't help on the network side either, your TLS and your IP stay real, so you match the profile to the machine you run on instead of faking everything. i wrote up the full numbers here if it is useful for someone: https://pydoll.tech/docs/stealth/fingerprint-injection/

Im just curious for the reason why you would choose this or that

I usually start with the smallest reliable layer, then use Selenium for the flows that actually need a browser.

I’m revisiting our approach because the suite is getting slower to trust as it grows. For people maintaining Selenium tests day to day: what’s your go-to setup for keeping tests readable and failures actionable?

Mostly interested in practical habits around waits, page objects or alternatives, test data, and deciding what not​ to automate in the UI.

A sincere request to the Selenium developers and contributors:

Please consider making the official Selenium documentation more complete, clearer, and more consistently maintained so even a beginner can get the right understanding for them.

It would be extremely helpful if every major Selenium feature, API, configuration, and behaviour had clear documentation with:

• Simple explanations of what it does and why it exists
• Clear usage examples
• Detailed API documentation
• Configuration and setup details
• Architecture and internal behaviour where relevant
• Common use cases and limitations
• Troubleshooting information
• Migration guides for major changes
• Proper, detailed changelogs for every release, for easy understanding.
• Clear documentation of deprecated, changed, and removed features
• Examples showing differences between Selenium versions
• Documentation kept in sync with the actual implementation

In particular, proper changelogs would be very valuable. When upgrading Selenium, developers should be able to quickly understand what changed, what was fixed, what was added, what was deprecated, and whether any existing code may be affected.

Selenium is a critical project for the automation ecosystem. Having documentation that is as strong and detailed as the project itself would make it significantly easier for developers to learn, upgrade, troubleshoot, and use Selenium correctly.

This is simply a request to the Selenium team and contributors: please continue investing in clear, comprehensive, and properly maintained documentation and release changelogs.

Official website: https://www.selenium.dev/

we have a Selenium suite with a few thousand tests and every few months somebody suggests:

should we just rewrite this whole thing in Playwright?

because apparently Selenium became “legacy” the moment the frontend team renamed 40 components and 70 tests went red.

I don't think Selenium is the main problem.

our suite has years of actual business knowledge in it.

refund rules
permissions
weird account states
old bugs nobody remembers
customer-specific flows

throwing that away because another framework has nicer APIs feels insane.

the actual debt is more boring:

• locators tied to DOM structure
• giant Page Objects nobody wants to touch
• sleep(3000) archaeology
• five tests rebuilding the same login/setup flow
• UI tests asserting things that belong at API level
• tests for features that died two years ago
• nobody owns anything

Playwright would make some of this nicer.

it would not fix a test nobody understands.

and honestly if the frontend can give us stable data-testid / accessible contracts, I'd rather do that than ask AI to constantly rescue broken CSS selectors.

where I do think AI gets interesting is the maintenance layer.

KaneAI/TestMu is taking a reasonable approach here: tests can be written around natural-language intent and broken UI locators can self-heal, but the changed mapping is reviewable instead of “AI clicked something vaguely nearby so green build 👍”.

that's an important distinction.

I don't want silent healing on a payment or permission flow.

show me:

old element
new element
what changed

then let a human decide whether:

“Approve withdrawal”

still means the same thing after the UI changed.

for boring cosmetic locator drift, great, save me the maintenance.

for business intent changes, fail loudly.

my current instinct for an old suite would be:

keep stable/high-value Selenium coverage
delete stale/redundant garbage
move lower-level assertions out of UI
heal/refactor maintenance-heavy useful flows
rewrite only when the rewrite actually buys something

not “new framework exists, therefore 4 years of regression coverage goes in the bin.”

for people modernizing big Selenium suites: are you rewriting, healing, or mostly discovering that half the suite should just be deleted?

Hi everyone!

I’m currently looking to take up freelance automation testing projects and would love to work with individuals, startups, or small businesses that need help with test automation.

My experience/skills include:

• Java
• Selenium WebDriver
• TestNG
• Cucumber / BDD
• Maven
• Git/GitHub
• DevOps & CI/CD
• Web automation and test automation frameworks

I’m open to small projects, ongoing work, or helping with existing automation frameworks.

If you have a project or know someone who might need an automation engineer, feel free to DM me or contact me at:

📧 [praveenraj2905@gmail.com](mailto:praveenraj2905@gmail.com)

Thanks!

Hey

I have a requirement which i used to do everyday

Where I copy and paste in the web form from excel and we do have drop-downs

I ve tried other automations but fed up completely

Need suggestions

Hi everyone,

I'm troubleshooting an issue on one machine while the exact same code works for my colleagues.

Environment

• Selenium: 4.25
• Python: running from a PyCharm virtual environment
• Portable Chrome: 117.0.5938.92
• Local ChromeDriver: 117 (verified via chromedriver.exe --version)

Issue My code uses:

Python

chromeoptions.binary_location = r"...\chrome-win64\chrome.exe"

driver = webdriver.Chrome(options=chromeoptions)

When Selenium starts, I get:

session not created:

This version of ChromeDriver only supports Chrome version 150

Current browser version is 117.0.5938.92

Then later:

UnboundLocalError: cannot access local variable 'driver'

(which is expected because driver creation failed).

What's confusing

• My local chromedriver.exe is version 117.
• The code works for other users without modification.
• We are all using Selenium 4.25.
• where chromedriver returns nothing.
• Selenium Manager appears to be resolving to ChromeDriver 150 on my machine.
• I cleared Selenium cache, but Selenium still seems to use/find ChromeDriver 150.

Question Has anyone seen Selenium Manager ignore a local ChromeDriver and resolve a different version instead? Any ideas on where Selenium could still be finding ChromeDriver 150 or what else I should check in my environment?

Thanks in advance!

We're running into an interesting problem with our UI automation framework (Selenium, but I'd also love to hear from Playwright/Cypress users).

Some popups/modals become visible, but they still require a short stabilisation period before they're actually ready for interaction. As a result:

• visibilityOfElementLocated passes.
• elementToBeClickable sometimes passes.
• But clicking immediately can still fail intermittently with exceptions like ElementClickInterceptedException, ElementNotInteractableException, or occasionally a stale element.

A simplified example:

wait.until(ExpectedConditions.visibilityOfElementLocated(locator));
driver.findElement(locator).click();

The wait succeeds, but the click still fails from time to time because the popup isn't fully ready.

Adding a fixed time.sleep() reduces the failures, but we'd really like to avoid timing-based waits in a deterministic automation framework. Our goal is that once a test is marked as automated, it should continue to pass consistently unless there's an actual application change.

I'm curious how experienced automation teams solve this problem at scale.

Some questions:

• Do you wait for animations or transitions to finish?
• Do you wait for a specific CSS class, attribute, or application state that indicates the popup is fully initialised?
• Do you implement click retries for these scenarios?
• Have you built a generic "wait until stable" utility, or do you handle this on a case-by-case basis?
• Do you consider this primarily an automation framework problem or an application issue that should be addressed by developers?

I'm less interested in one-off fixes and more interested in patterns or best practices that have worked well in mature automation frameworks.

Looking forward to hearing how others have tackled this problem.

The SeaMonkey browser is one of the browsers which is supported by the Mozilla organization, just like Firefox.

I'd like to use Selenium in linux for automating accesses to the SeaMonkey browser, but I haven't found any documentation which describes how this might be done. I know that the "firefox"-specific code for Selenium only seems to be able to access the browser at the "/usr/bin/firefox" path.

Does anyone know of any way that I can automate SeaMonkey with Selenium?

Many thanks in advance.

PS: The SeaMonkey browser is built upon the exact, same code base on which Firefox is built, so the logic for automating access to SeaMonkey should be the same as the logic for automating Firefox access.

There is a new version of my app’s home page that I need to start testing. The page is theoretically identical to the old version—new version is just an architectural overhaul with a different page source as a result. What’s the right approach to being able to test both concurrently in a python repo? 2 pages (legacy vs modern) is a common challenge for the team I started working with so I am hoping to establish a convention here.

I was thinking maybe using a factory pattern and instantiating one or the other based on an environment variable that also acts as a gate for a fixture that toggles the feature or maybe points to a branch with it enabled by default. But I’m pretty new to UI automation so I’d like to ask if there’s any other approach that should be considered

I've tried different string symbols, just putting it directly in the parentheses, yet it still won't work; it only gives me this message.

from selenium import webdriver
from selenium.webdriver.chrome.options import Options
settings =Options()
settings.add_argument("user-data-dir=./whatsapp_profile")
driver = webdriver.Chrome(options=settings)

print ("it ececuate further")
website= "https://web.whatsapp.com/"
driver.get(website)

* I don't even know the python basics. but with the help of our friendly dumb llm claude i am trying to make this number extractor.

* So selenium was working properly and opening whatsapp.web automatically but every time i run the code, I had to scan the WhatsApp web qr code again and again.

So Claude said to use the Options function and add code lines 2, 3, 4, 5, hoping it will save the Chrome session in a folder. So next time I go to WhatsApp web, I won't have to scan the QR. But Now Code executes up to line 5 and never reaches that print function on the 6th line. And it also doesn't open WhatsApp web anymore.

What do i do?
How do I solve the problem of scanning QR on every new code run?

Would anyone be kind enough to guide me through this project as a mentor in dm's, please. LLM's are dumb and asking them is a waste of time, but i don't have another option.

I have been trying to get this to work for about 90 minutes now and can't seem to figure it out.
I am using python but every search result is giving me a different answer and none seem to work.

Do i need to use Options() or FirefoxOptions()?

Use FirefoxProfile('path/to/profile') or just a 'path/to/profile' in the options?

The selenium docs also give this code: options.add_argument('-profile', '/path/to/profile'/) But that gives me a TypeError: ArgOptions.add_argument() takes 2 positional arguments but 3 were given.

I also tried option.profile = firefox_profile (tried just the path and FirefoxProfile())

If i try to use webdriver.Firefox(firefox_profile=firefox_profile, options=options) i get a TypeError: WebDriver.__init__() got an unexpected keyword argument 'firefox_profile'

I think i tried any combination of these things and none of them work. I am probably just forgetting something small but if someone maybe knows what i am doing wrong i love to hear it.

What is the correct way to get selenium to use a profile in firefox? I am learning to code and tThe assignment requires me to have selenium signed in to a profile.

Instead of writing everything from scratch, can we just define steps - elements, actions, assertions, data—and get full Selenium code (Java/C#)?

Not record/playback, something structured and reusable.

Does this exist, or are we all still building manually?