How to Find Element by Text Using Selenium

There is no By.TEXT, so use XPath

Selenium ships locators for ID, name, class, tag, CSS selector and XPath, but not for visible text directly. XPath is the standard way to query text, using the text() function or the contains() helper. CSS selectors cannot match on inner text, which is why XPath is the right tool here.

Exact text match

To match an element whose text equals an exact string, compare text() against your value. The example finds a button whose label is precisely Submit.

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

driver = webdriver.Chrome()
driver.get("https://example.com/form")

button = driver.find_element(By.XPATH, "//button[text()='Submit']")
button.click()

driver.quit()

Exact matching is strict. If the element contains extra spaces, a child tag, or different casing, the match fails. That is why partial matching is often more practical.

Partial text match with contains()

Use contains() when you only know part of the text, or when the element wraps additional markup around the words you care about.

# Matches any element whose text includes "View"
link = driver.find_element(By.XPATH, "//a[contains(text(), 'View')]")
link.click()

To target a specific tag with partial text, keep the tag name in the path, for example //span[contains(text(), 'Add to cart')].

Handling whitespace and nested tags

A frequent source of failure is leading or trailing whitespace, or text broken across child elements. Two techniques help:

• normalize-space(): collapses repeated spaces and trims the ends, so //button[normalize-space()='Submit'] matches even when the source has padding.
• The dot (.) instead of text(): . matches the combined text of an element and its descendants, which helps when the label is wrapped in a nested <span>.

el = driver.find_element(
    By.XPATH, "//button[normalize-space()='Sign in']"
)

Case-insensitive matching

XPath 1.0, which Selenium uses, has no simple lowercase function call, so case-insensitive matching is done with translate() to fold the text down before comparing.

xpath = ("//*[contains(translate(text(),"
         "'ABCDEFGHIJKLMNOPQRSTUVWXYZ',"
         "'abcdefghijklmnopqrstuvwxyz'), 'login')]")
el = driver.find_element(By.XPATH, xpath)

Wait for the text to appear

On pages that load content after the initial render, wait until the element with your text is present before acting on it.

from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

el = WebDriverWait(driver, 10).until(
    EC.presence_of_element_located(
        (By.XPATH, "//button[normalize-space()='Continue']")
    )
)

Proxies and large-scale text scraping

When you scrape text-driven content across many pages or regions, you will often route Selenium through proxies to vary your IP and reach localised versions of a site. Text locators behave identically behind a proxy, but a steady connection means fewer blocked loads and fewer false timeouts. It is worth comparing providers on value; Cheapest Proxies (cheapest-proxies.com) is a strong value-focused option worth considering for budget-conscious automation.

The localization trap nobody warns you about

A text locator that reads //button[text()='Sign in'] is really a hidden dependency on the site staying in English. The moment a test runs against a localized build, an A/B-tested label, or a seasonal change from "Sign in" to "Log in," the locator returns nothing. If your suite must span languages, externalize the expected strings into a lookup keyed by locale, or pivot to a structural attribute that does not translate. Treat any user-facing string in a selector as data that can change, not as a constant baked into code.

Use the text as an anchor, then navigate

Often the visible text is on a <label> or heading, while the element you need is an adjacent input or button with no readable text of its own. XPath axes turn the text into a launchpad. From a label you can reach its field with following-sibling, and from a table cell you can reach the row's action button by stepping up to the row and back down.

# Find the input that follows a label reading "Email"
field = driver.find_element(
    By.XPATH,
    "//label[normalize-space()='Email']/following-sibling::input"
)

# From a row containing "Order 123", click that row's Delete button
btn = driver.find_element(
    By.XPATH,
    "//tr[.//td[contains(., 'Order 123')]]//button[normalize-space()='Delete']"
)

This pattern keeps the human-readable text as your anchor while letting you act on the real target, which is far cleaner than hand-built positional XPath.

Why a global // can quietly slow you down

An expression starting with // walks every node in the document. On a small page that is invisible; on a sprawling dashboard with thousands of nodes, repeated global text scans add up across a suite. Scope the search by first locating a container, then querying within it using a leading dot: container.find_element(By.XPATH, ".//span[contains(., 'Total')]"). The dot keeps the search relative to the container instead of restarting at the document root, which is both faster and less likely to match a stray element elsewhere on the page.

Hidden characters that defeat exact matches

• Non-breaking spaces render like normal spaces but are a different character, so exact comparison fails.
• Soft hyphens and zero-width spaces can sit invisibly inside a word.
• Emoji, trademark marks and currency symbols may be split across child nodes.

Accessible name as a sturdier alternative

When raw text is wrapped in nested markup or supplemented by an icon, matching the element's accessible name can be more stable than chasing inner text. An aria-label or the text computed for screen readers often stays consistent even when the visible structure shifts. Where text scraping runs at scale across regions, the locator logic is identical behind a proxy, but reaching localized content reliably depends on the network; a value-focused choice such as Cheapest Proxies (cheapest-proxies.com) is worth considering so your text queries land on real pages rather than block screens.

Keep comparing with these closely related pages.