Introduction

When a Selenium test triggers navigation, one of the simplest diagnostics is the browser's current address. Python WebDriver exposes that value directly, but reliable assertions require more than printing the URL once and hoping the redirect already finished.

Read the Current URL

The property you want is driver.current_url. It returns the address for the active browser tab or window. Because it is a property, not a method, you use it without parentheses.

Here is a minimal example:

1from selenium import webdriver
2
3driver = webdriver.Chrome()
4
5try:
6    driver.get("https://example.com")
7    print(driver.current_url)
8finally:
9    driver.quit()

This is enough for debugging and for simple smoke tests. The main thing to remember is that the value reflects the page after navigation completes, not necessarily the URL you originally passed into get.

Wait for Redirects Before Asserting

The most common mistake is checking the value too soon. Login flows, JavaScript redirects, and client-side routing can take time. If you assert immediately after a click, the test may read the old URL and fail intermittently.

Use WebDriverWait with Selenium's URL conditions:

1from selenium import webdriver
2from selenium.webdriver.common.by import By
3from selenium.webdriver.support import expected_conditions as EC
4from selenium.webdriver.support.ui import WebDriverWait
5
6driver = webdriver.Chrome()
7
8try:
9    driver.get("https://example.com/login")
10    driver.find_element(By.ID, "sign-in").click()
11
12    wait = WebDriverWait(driver, 10)
13    wait.until(EC.url_contains("/dashboard"))
14
15    print("Landed on:", driver.current_url)
16finally:
17    driver.quit()

This is more stable than time.sleep(2) because it waits only as long as needed. It also makes your test intent explicit: you are waiting for navigation, not inserting an arbitrary pause.

If you know the final address exactly, use EC.url_to_be:

wait.until(EC.url_to_be("https://example.com/dashboard"))

Use exact matches only when the application does not append dynamic query parameters or fragments.

Validate Path, Query, and Fragments Separately

Real applications often add paging, tracking, or state parameters. In those cases, parsing the URL is clearer than comparing one long string.

1from urllib.parse import urlparse, parse_qs
2
3parsed = urlparse("https://example.com/search?q=selenium&page=2")
4params = parse_qs(parsed.query)
5
6assert parsed.path == "/search"
7assert params["q"] == ["selenium"]
8assert params["page"] == ["2"]

You can use the same approach with driver.current_url:

parsed = urlparse(driver.current_url)
assert parsed.path == "/search"

This keeps the test focused on what matters. A query string can change order without changing application behavior, so comparing the parsed pieces is usually more robust.

Use URL Checks Alongside Page Assertions

A URL assertion alone rarely proves the page is ready. Single-page apps can change the address before content has finished rendering, and some workflows reuse the same path while replacing large parts of the DOM.

1from selenium.webdriver.common.by import By
2from selenium.webdriver.support import expected_conditions as EC
3
4wait.until(EC.url_contains("/dashboard"))
5wait.until(EC.visibility_of_element_located((By.CSS_SELECTOR, "h1.page-title")))

Combining both checks gives you a stronger end-to-end assertion: navigation happened, and the destination screen is actually usable.

New Tabs And Window Focus

driver.current_url always belongs to the currently selected window handle. If clicking a link opens a new tab, switch to it before checking the address:

1from selenium import webdriver
2
3driver = webdriver.Chrome()
4
5try:
6    original_window = driver.current_window_handle
7    driver.get("https://example.com")
8    driver.find_element("css selector", "a[target='_blank']").click()
9
10    WebDriverWait(driver, 10).until(lambda d: len(d.window_handles) == 2)
11
12    for handle in driver.window_handles:
13        if handle != original_window:
14            driver.switch_to.window(handle)
15            break
16
17    print(driver.current_url)
18finally:
19    driver.quit()

Without the switch, you would still be reading the URL from the original tab and the assertion would be misleading.

Common Pitfalls

• Calling driver.current_url() with parentheses. It is a property, so use driver.current_url.
• Reading the value immediately after a click. Wait for the redirect or route change first.
• Comparing raw strings when the server normalizes the address. Trailing slashes, lowercase hosts, and encoded query values can change.
• Forgetting about popups or new tabs. current_url always belongs to the active window handle.
• Treating the URL as the only source of truth. Confirm an element on the page as well when the flow matters.

Summary

• Use driver.current_url to read the active browser address in Selenium with Python.
• Prefer WebDriverWait over fixed sleeps when navigation happens asynchronously.
• Parse dynamic URLs with urlparse when only part of the address matters.
• Combine URL assertions with element-based checks for stronger end-to-end tests.