How to Handle Elements Using XPath in Selenium

Rohit Rajpal

September 17, 2025

11MIN READ

Learn how to use XPath in Selenium for locating elements, handling dynamic attributes, and running reliable cross-browser tests.

XPath in Selenium is one of the most powerful ways to locate elements when building automated tests. It allows testers to work with simple and complex page structures, making it easier to handle both static and dynamic elements.

XPath expressions can target elements based on attributes, hierarchy, or text, which makes them more flexible than basic locators like ID or name.

This article covers XPath in Selenium, its types, chained XPath, commonly used axes, and methods for handling dynamic elements.

Understanding XPath in Selenium

XPath (XML Path Language) is a query language used to navigate through elements and attributes in XML documents. Since modern web pages follow an HTML structure that is similar to XML, Selenium uses XPath to locate elements on a web page. XPath provides a flexible way to identify elements based on their hierarchy, attributes, or visible text.

Unlike simpler locators such as ID or name, XPath can handle complex DOM structures. It allows testers to target elements even when they lack unique identifiers, making it an essential locator strategy for robust automation scripts.

Why XPath is Important in Selenium Testing

XPath is a critical locator strategy in Selenium because it works even when elements lack unique identifiers or are deeply nested in the DOM. It provides flexibility to target elements in ways that other locators cannot.

Key reasons why XPath is important:

Locating dynamic elements: Many modern applications generate IDs or class names dynamically. XPath allows selection through partial matches, attribute combinations, or text, which ensures scripts remain stable even when values change.
Navigating complex hierarchies: Some elements are buried inside multiple nested tags or frames. XPath can traverse parent, child, and sibling relationships, making it possible to pinpoint elements regardless of their position.
Using attribute-based targeting: XPath supports a wide range of attributes beyond ID and class, such as title, data-*, or custom attributes, which expands the options for precise selection.
Text-based identification: When attributes are insufficient, XPath can locate elements using exact or partial text values, useful for menus, labels, or dynamic content.
Combining multiple conditions: XPath supports logical operators like and and or, enabling robust queries that handle complex scenarios where a single condition is not enough.

Absolute and Relative XPath Explained

XPath in Selenium can be written in two main forms: absolute and relative. Both are valid for locating elements, but they behave differently and are suited to different scenarios.

1. Absolute XPath

Absolute XPath describes the path to an element starting from the root (html) and going through every node until the target element. It follows a strict hierarchy and uses indexes when multiple elements are present at the same level.

Example:

				
					/html/body/div[1]/div[2]/ul/li[3]/a

This expression selects the third list item (li[3]) inside a specific ul. While it precisely defines the element, even a minor change in the DOM structure (such as adding a new div) will break the XPath.

2. Relative XPath

Relative XPath starts from any node in the DOM and does not require the full path from the root element. It uses attributes, text, or partial matches to locate elements more flexibly.

Example:

				
					//a[@href='/login']  
//button[text()='Submit']  
//input[contains(@name, 'user')]

These expressions locate elements directly using conditions rather than relying on the full DOM path. Relative XPath is shorter, more resilient to changes, and the recommended approach for Selenium scripts.

Difference Between Absolute and Relative XPath

Both absolute and relative XPath can locate elements, but their behavior, reliability, and suitability for automation differ significantly. Testers should understand these differences clearly so they can choose the right approach depending on the application under test.

Aspect	Absolute XPath	Relative XPath
Starting Point	Always begins from the root element (/html)	Can begin from anywhere in the DOM (//)
Syntax Example	/html/body/div[1]/ul/li[2]/a	//a[@href=’/login’]
Readability	Long and harder to read	Short and easy to understand
Maintenance	Breaks easily if the page structure changes	More resilient to DOM changes
Performance	Slightly faster as it follows a direct path from the root	Slightly slower as it may scan the entire DOM
Flexibility	Limited, requires exact hierarchy	High, supports attributes, text, and functions
Use in Dynamic Pages	Not suitable, as the structure often changes	Suitable, as it adapts to dynamic content
Error Debugging	Errors are harder to trace due to long paths	Errors are easier to spot due to simpler expressions
Practical Usage	Rarely used in production, mainly for learning	Commonly used in real-world Selenium tests

Chained XPath in Selenium

Chained XPath is useful when an element cannot be uniquely identified using a single attribute or path. Instead of writing one long and fragile expression, you can break it into smaller segments and chain them together. This makes the XPath more readable and easier to maintain, especially for complex or deeply nested elements.

Example 1: Input field inside a container

				
					//div[@class='form-container']//input[@type='text']

This expression locates a text input box that exists inside a div with the class form-container. Even if there are multiple inputs on the page, the chaining ensures only the input within the container is selected.

Example 2: Link inside an active menu item

				
					//ul[@id='menu']//li[@class='active']//a

This expression finds the anchor tag inside the currently active list item of a menu. It narrows the scope step by step, first the ul with id=’menu’, then the li with the class active, and finally the link inside it.

Why Use Chained XPath

Chained XPath is not always required, but it becomes valuable when dealing with applications that have repetitive elements or complex nesting. It helps testers write expressions that are both precise and maintainable.

Key advantages of using chained XPath:

Improved readability: Breaking down long expressions into smaller chained parts makes them easier to read and understand.
Targeting nested elements: Useful for locating elements buried inside multiple layers of containers, lists, or forms.
Higher accuracy: Reduces the risk of selecting the wrong element when many elements share similar attributes.
Better maintainability: If the structure of one part of the DOM changes, only a portion of the chained XPath may need to be updated instead of rewriting the entire expression.
Step-by-step filtering: Allows narrowing down the search progressively, which is especially helpful in dynamic or component-heavy web applications.

XPath as a Locator Strategy

In Selenium, XPath is one of the most versatile locator strategies. While other locators like ID, name, or CSS selectors are often faster, XPath stands out because it can locate almost any element, even when attributes are missing, dynamic, or inconsistent. This makes it a reliable choice for handling complex web applications.

Examples of XPath as a Locator

1. Locating a button by ID

				
					//button[@id='login-button']

This expression selects the login button using its unique id. It’s a straightforward case where the element is already given a stable identifier.

2. Locating an element by visible text

				
					//span[text()='Add to Cart']

This expression targets the “Add to Cart” label on an e-commerce page. It’s useful when the element doesn’t have a unique attribute but can be identified by its displayed text.

3. Locating an element with a partial attribute match

				
					//input[contains(@placeholder, 'email')]

This expression selects an input field where the placeholder contains the word “email.” It’s valuable in forms where placeholder values vary, such as “Enter your email” or “Email address.”

Benefits of XPath Locators

XPath offers capabilities that go beyond basic locators like ID, name, or CSS. Its flexibility makes it one of the most reliable strategies for handling diverse scenarios in Selenium automation.

Key benefits include:

Universal applicability: Can locate elements without IDs or names. For example, //div[@class=’banner’] can target a container even if no unique identifier is present.
Dynamic element handling: Useful when attributes change dynamically. For example, //input[contains(@id, ‘user_’)] matches an input field even if the numeric suffix changes with every refresh.
Text-based selection: Targets elements by visible text. For example, //button[text()=’Login’] works when the button has no consistent ID or class.
Hierarchical navigation: Allows moving through parent-child relationships. For example, //div[@class=’card’]//span[@class=’title’] fetches the title inside a specific card component.
Combining conditions: Enables precise selection. For example, //a[@class=’nav-link’ and text()=’Home’] ensures the correct link is selected when multiple elements share the same class.
Cross-browser reliability: Provides stable results across browsers. For example, //img[@alt=’Logo’] works consistently in Chrome, Firefox, and Safari without browser-specific adjustments.

Limitations of XPath Locators

While powerful, XPath is not without drawbacks. Testers must be aware of these limitations to avoid fragile or slow scripts.

Common limitations include:

Performance overhead: XPath can be slower on large DOMs. For example, //div//span forces Selenium to scan many nodes, which impacts execution speed compared to a CSS selector.
Fragility in long expressions: An absolute path like /html/body/div[2]/ul/li[3]/a will break if a new div is added in the hierarchy.
Readability challenges: Overly chained XPaths such as //div[@class=’main’]//table//tr[3]//td[2]//span can confuse teams reviewing the code.
Cross-browser quirks: Older Internet Explorer versions handle certain XPath functions inconsistently. For example, starts-with() may not behave the same way as in Chrome.
Higher complexity: Requires more learning to write efficient expressions. For example, understanding when to use contains() vs starts-with() can be tricky for new testers.

XPath Axes in Selenium

XPath axes define relationships between elements in the DOM. Instead of selecting elements only by attributes or text, axes allow navigation through parent, child, ancestor, descendant, and sibling nodes. This makes them highly effective when elements are located relative to others.

Common Use Cases of XPath Axes

The following examples show how different axes help in locating elements based on their relationships in the DOM:

1. Selecting a child element

				
					//div[@class='product']//child::span

This finds the span element that is a direct child of a div with class product. It’s useful when multiple child elements exist, but you want a specific one inside a container.

2. Selecting a parent element

				
					//span[text()='Price']//parent::div

This selects the parent div of a span with the text “Price.” It helps when you locate a child easily, but you need to interact with its container.

3. Selecting a following sibling

				
					//label[text()='Username']//following-sibling::input

This locates the input field that directly follows the label “Username.” It’s common in forms where the label is easier to identify than the input.

4. Selecting a preceding sibling

				
					//input[@id='password']//preceding-sibling::label

This finds the label associated with the password field. It’s helpful for validation when you need to confirm both the field and its label.

5. Selecting all descendants

				
					//div[@class='cart']//descendant::button

This expression selects all button elements inside the cart container, no matter how deeply nested they are.

Handling Dynamic Elements with XPath in Selenium

Dynamic elements are common in modern applications where IDs, classes, or names change frequently. These changes can break static locators, so testers rely on XPath expressions that adapt to patterns rather than fixed values.

1. Attribute-Based Selection

Dynamic attributes often include a consistent substring even though the full value changes. XPath functions like contains() or starts-with() help in targeting such elements.

				
					//input[contains(@id, 'user_')]

This expression selects any input element whose id includes the substring user_. For example, it will work for IDs like user_123 or user_temp.

				
					//button[starts-with(@class, 'btn-')]

This finds any button where the class begins with btn-, which is useful when classes follow a pattern like btn-primary or btn-secondary.

2. Using Logical Operators

Sometimes one condition is not enough to uniquely identify an element. Logical operators such as and and or allow combining multiple criteria in a single XPath expression.

				
					//button[@type='submit' and contains(@class, 'primary')]

This selects a submit button only if it also has a class containing primary. It ensures precision when multiple submit buttons exist.

				
					//input[@type='checkbox' or @type='radio']

This expression matches both checkboxes and radio buttons. It is useful for form testing when you want to validate different input types at once.

3. Text-Based Selection

When attributes are unpredictable, visible text on the page can serve as a stable locator. XPath provides functions like text() and contains(text(), …) to capture such cases.

				
					//a[contains(text(), 'Next')]

This locates a link that includes the word “Next,” often used in pagination controls where IDs and classes change across pages.

				
					//span[text()='Add to Cart']

This directly finds the span with exact visible text “Add to Cart,” which is reliable for button or label elements tied to user actions.

How BrowserStack Automate Supports XPath Testing

XPath works the same way across local and cloud environments, but large-scale testing often brings challenges like varied browsers, devices, and dynamic application states. BrowserStack Automate provides a reliable cloud infrastructure to run Selenium tests at scale, ensuring that XPath-based locators work consistently across different real environments.

Cross-browser and device coverage: Run Selenium tests with XPath locators on 3,500+ real browsers and devices to confirm consistent behavior across environments.
Dynamic element handling: Execute XPath functions like contains() and starts-with() on real applications where IDs and attributes frequently change.
Built-in debugging tools: Access screenshots, video recordings, and console logs whenever an XPath fails, making it easier to identify and fix locator issues.
Parallel test execution: Scale test suites with multiple XPath-based locators by running tests in parallel, reducing execution time.
CI/CD integration: Automate XPath-based Selenium tests directly within your existing CI/CD pipelines for continuous quality assurance.

Conclusion

XPath is one of the most versatile locator strategies in Selenium. It allows testers to handle dynamic attributes, navigate complex DOM structures, and reliably interact with elements when simpler locators fall short. Techniques like relative paths, axes, and text-based selection make it a key part of stable test automation.

With BrowserStack Automate, XPath testing extends beyond local setups into real-world conditions. Teams can validate XPath locators across thousands of real browsers and devices, debug failures with logs and screenshots, and integrate tests seamlessly into CI/CD pipelines.

Written by

Rohit Rajpal

Rohit Rajpal is a B2B Content Strategist at BrowserStack, helping SaaS brands build AI-first strategies that drive authority and revenue. He writes about content, strategy, and the future of search in the zero-click era.

CSS Selector in Selenium: Complete Tutorial with Examples

Learn how to use CSS selectors in Selenium to locate elements, handle dynamic content, and write robust automation tests.

Rohit Rajpal

September 17, 2025

What is Page Object Model in Selenium: Principles and Examples

Learn what the Page Object Model in Selenium is, its principles, examples, and how Page Factory extends POM for scalable test automation.

Rohit Rajpal

September 17, 2025

Mastering Selenium Wait Commands

Learn Selenium wait commands with examples, differences, and best practices to build reliable automated tests.

Azma Banu

September 17, 2025

How to Handle Elements Using XPath in Selenium

Understanding XPath in Selenium

Why XPath is Important in Selenium Testing

Absolute and Relative XPath Explained

1. Absolute XPath

2. Relative XPath

Difference Between Absolute and Relative XPath

Chained XPath in Selenium

Why Use Chained XPath

XPath as a Locator Strategy

Examples of XPath as a Locator

Benefits of XPath Locators

Limitations of XPath Locators

XPath Axes in Selenium

Common Use Cases of XPath Axes

Handling Dynamic Elements with XPath in Selenium

1. Attribute-Based Selection

2. Using Logical Operators

3. Text-Based Selection

How BrowserStack Automate Supports XPath Testing

Conclusion

How to Guides

Case Studies