How to Automate Mouse Clicks with Selenium Python

For an ordinary click, locate the element and call element.click(). Selenium scrolls an out-of-view target into view and checks whether it is interactable. Use ActionChains when you need a mouse gesture or sequence such as hovering, right-clicking, double-clicking, holding, or dragging. If the target’s center is covered by another element, Selenium can raise an intercepted-click error.

1. Install Selenium and prepare a browser

Install Selenium in a virtual environment so the project’s dependencies stay isolated. Selenium’s current Python API reference lists Python 3.10+ support. Modern Selenium includes Selenium Manager, which can manage browser drivers automatically in common setups.

python -m venv .venv
# macOS or Linux:
source .venv/bin/activate
# Windows PowerShell:
# .venv\\Scripts\\Activate.ps1
python -m pip install -U selenium

Save the examples below as a Python file and run them with the environment activated. They use Chrome; Selenium also supports other browsers, including Edge, Firefox, and Safari. If automatic driver management is unavailable in your environment, install or configure the browser and driver according to Selenium’s official documentation.

See the Selenium documentation and official first-script example for setup details. Version and browser support can change over time.

2. Click an element with WebElement.click()

Use the standard element click for buttons, links, checkboxes, and other elements that should respond to a normal browser click. Prefer a locator that identifies the intended control reliably; a stable ID or a specific CSS selector is usually clearer than a broad selector.

from selenium import webdriver
from selenium.webdriver.common.by import By


def main():
    driver = webdriver.Chrome()
    try:
        driver.get("https://example.com")
        button = driver.find_element(By.CSS_SELECTOR, "button")
        button.click()
        print("Clicked the button")
    finally:
        driver.quit()


if __name__ == "__main__":
    main()

Replace the example URL and selector with the page and target you need. find_element returns one matching element and raises an exception if there is no match. When the page renders the target asynchronously, wait for it instead of assuming it exists immediately.

Wait for a target before clicking

Explicit waits poll for a condition and help avoid racing page load or client-side rendering. This example waits until the element is clickable, clicks it, and closes the browser even if an error occurs.

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.ui import WebDriverWait


def main():
    driver = webdriver.Chrome()
    try:
        driver.get("https://example.com")
        wait = WebDriverWait(driver, 10)
        button = wait.until(
            EC.element_to_be_clickable((By.CSS_SELECTOR, "button"))
        )
        button.click()
    finally:
        driver.quit()


if __name__ == "__main__":
    main()

The timeout is an example, not a universal setting. Choose one that fits the application and test environment. A wait can confirm that Selenium considers the element clickable, but it cannot guarantee that the application’s server-side action will succeed.

3. Use ActionChains for mouse gestures

ActionChains queues mouse actions. Call perform() to execute the queued sequence. Use its gesture methods when the interaction involves pointer movement, multiple presses, or a held button.

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.action_chains import ActionChains


def main():
    driver = webdriver.Chrome()
    try:
        driver.get("https://example.com")
        target = driver.find_element(By.CSS_SELECTOR, "button")
        actions = ActionChains(driver)

        # Hover, then left-click the element.
        actions.move_to_element(target).click().perform()
    finally:
        driver.quit()


if __name__ == "__main__":
    main()

The following patterns cover common mouse interactions. Each one assumes driver is an active WebDriver and element is a located WebElement.

from selenium.webdriver.common.action_chains import ActionChains

# Left-click the element with an action chain.
ActionChains(driver).click(element).perform()

# Right-click (context menu).
ActionChains(driver).context_click(element).perform()

# Double-click.
ActionChains(driver).double_click(element).perform()

# Move the pointer over an element, triggering hover behavior.
ActionChains(driver).move_to_element(element).perform()

# Press and hold, then release on the same element.
ActionChains(driver).click_and_hold(element).release().perform()

# Drag one element onto another.
ActionChains(driver).drag_and_drop(source, destination).perform()

For a click at a position relative to an element, use an offset. Offsets are relative to the element’s center.

# Click 10 pixels right and 5 pixels below the element center.
ActionChains(driver).move_to_element_with_offset(element, 10, 5).click().perform()

Choose an offset only when the UI requires a specific point. Layout changes, scrolling, scaling, and responsive breakpoints can make coordinate-based interactions brittle.

The documented mouse actions include left, right, back, and forward buttons; middle-click is currently unsupported. Use only the mouse behavior Selenium documents for the browser and driver in use. See the Selenium mouse actions reference.

4. Choose the right click method

Need	Use	Notes
Activate a button, link, or control normally	element.click()	Direct and readable; checks interactability and targets the element center.
Right-click or double-click	ActionChains.context_click() or double_click()	Build the gesture, then call perform().
Hover before interacting	ActionChains.move_to_element()	Useful for menus and hover-triggered content.
Hold, drag, or move with the pointer	ActionChains.click_and_hold(), drag_and_drop(), or movement methods	Use when the sequence itself matters, such as dragging a slider or item.
Click at an element-relative point	ActionChains.move_to_element_with_offset() followed by click()	More sensitive to layout changes than locating and clicking a semantic control.

Do not switch to a JavaScript-triggered click simply because a user-like click is failing. A script-dispatched event is a different interaction from WebDriver’s pointer action, and may not exercise the same hit-testing or user interaction behavior. Diagnose why the normal click cannot reach the target first.

5. Diagnose intercepted and failed clicks

Symptom	Likely cause	What to do
Element click intercepted	A modal, overlay, sticky header, cookie banner, or another element covers the target’s center.	Inspect the page at the time of the failure. Wait for the obstruction to disappear or dismiss it through the intended UI, then retry.
No such element	The locator does not match, the page has not rendered the element, or the element is inside a frame.	Check the selector and page state. Wait for rendering; if the control is in a frame, switch to that frame before locating it.
Element not interactable	The element may be hidden, disabled, or otherwise not ready for interaction.	Wait for the relevant state and target the visible, enabled control. Check whether the page has an alternate visible element with the same label.
Click runs but the expected change does not happen	The click may be accepted while app validation, network activity, or a required follow-up state is still pending.	Wait for the expected application state, such as a confirmation element or URL change. Assert that outcome separately from the click.
Timeout waiting for clickable state	The locator is wrong, an overlay remains, the page is slow, or the control never becomes enabled.	Inspect the DOM and page state, verify the locator, and use a timeout appropriate to the workflow. Fix the underlying blocker rather than increasing every timeout indiscriminately.
Driver or browser startup error	The browser is missing, incompatible, or cannot be managed in the current environment.	Check Selenium’s setup guidance, browser installation, driver availability, and environment restrictions. Configure a driver explicitly when Selenium Manager cannot handle the setup.

Selenium’s element click targets the center of the element. When that point is obscured, the intercepted-click error is useful evidence: the browser is reporting a hit-testing problem, not necessarily a bad selector. Waiting for the obstruction to go away is usually the right repair.

6. Make click automation more reliable

• Use explicit waits for page conditions instead of fixed sleeps wherever possible.
• Locate controls with selectors tied to stable attributes and scope broad selectors to the relevant part of the page.
• Wait for the application outcome after clicking; a successful click call alone does not prove the workflow completed.
• Keep browser cleanup in a finally block or use a test framework fixture so failures do not leave sessions running.
• When a click is intercepted, capture enough diagnostic context to identify overlays, layout changes, and the active page state.
• Keep tests independent where practical, and reset application state between runs so earlier clicks do not change later expectations.

For work that needs remote browsers or more parallel test capacity, Selenium documents Remote WebDriver and Selenium Grid. These add infrastructure and configuration considerations; choose them when local execution no longer fits the required browser coverage or scale.

7. Performance, reliability, and cost

A click command is only one step in a browser workflow. End-to-end time also depends on browser startup, navigation, page rendering, waits, and application responses. Reusing a browser session across related steps can avoid repeated startup, while isolated sessions make cleanup and test independence easier. Balance reuse against the need for clean state.

For reliability, wait on meaningful conditions rather than adding long fixed delays. For cost, Selenium itself is an open-source browser automation project; infrastructure costs depend on where and how browsers run, including any remote grid or hosted execution you choose. The research sources do not provide a universal runtime, success rate, or per-click cost, so those figures depend on your environment and workload.

8. Or skip the browser setup

If your goal is a clean screenshot rather than interacting with a page, ScreenshotNeo can capture a URL with one API request. Its documentation describes the screenshot API, which can return PNG, JPEG, WebP, or PDF. For example, this cURL command saves a WebP screenshot:

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

ScreenshotNeo removes cookie banners, popups, and chat widgets before the shot. Bot checks, blank pages, and failed loads are never billed. Its MCP server lets AI agents take screenshots. The free plan includes 1,000 screenshots per month with no card; paid plans start at $5 for 3,000. See ScreenshotNeo for product details.

Sign up free for 1,000 screenshots a month, no card required.

9. FAQ

Does Selenium click the center of an element?

Yes. The standard WebDriver element click targets the element center, which is why an overlay covering that point can intercept it.

Should I use ActionChains for every click?

No. Use element.click() for a normal element activation. Reach for ActionChains when you need a pointer gesture, sequence, or position-sensitive interaction.

Can Selenium middle-click an element?

The Selenium mouse actions reference says middle click is currently unsupported. Check the current documentation for changes before relying on a particular button action.

Can I run these interactions on remote browsers?

Yes. Selenium supports remote browser control through Remote WebDriver, and Selenium Grid is documented for scaling execution across machines and browser configurations.