Mastering XPath in Selenium: A Complete Tutorial

XPath is used to find and locate elements on a web page. Web pages are made up of HTML, which is like a tree structure. XPath helps you navigate that tree and pick out exactly what you want, whether it’s a button, a text field, a checkbox, or anything else.

What Is XPath in Selenium?

XPath or XML Path Language is a query language to navigate through elements and attributes in XML and HTML documents. Since HTML pages are structured as a Document Object Model (DOM), XPath lets you define a path to any element or node based on its position, attributes, or relationships to other nodes.

Syntax:

In test automation, XPath is often used when other Selenium locators, like tags or CSS class names are not enough to select all elements in the DOM. That’s why XPath is often used, especially when elements lack unique IDs, require navigating parent-child relationships, or are deeply nested or dynamic.

Types of XPath in Selenium

There are two types of XPath in Selenium:

• Absolute XPath
• Relative XPath

Absolute XPath

Absolute XPath gives the complete path from the root element all the way down to your target element.

Syntax:

Features:

• Starts with a single slash /.
• Follows the exact structure of the page.
• Breaks easily if any part of the layout changes.

Relative XPath

Relative XPath starts from anywhere in the DOM, not necessarily from the root.

Syntax:

Features:

• Starts with double slashes //, which means “anywhere on the page”.
• Lets you use attributes, text, and partial matches.
• Works even if the structure around the element changes.

How to Write XPath in Selenium?

Let’s see how to write XPath in Selenium with various methods using real-world examples:

Basic Attribute Matching

XPath is used to locate elements in a web page by combining the HTML tag and an attribute-value pair.

Syntax:

Example:

contains()

contains() is useful when attribute values are partially known or change dynamically.

Syntax:

Example:

Logical Operators (and/or)

Logical operators let you combine multiple conditions in a single XPath.

Syntax (or):

Syntax (and):

Example (or):

Example (and):

Note: Always use lowercase and and or as XPath is case-sensitive.

text()

Use text() to find elements based on the visible text between tags.

Syntax:

Example:

starts-with()

starts-with() helps when an attribute’s value begins with a consistent prefix.

Syntax:

Example:

Index

Use index when multiple elements match the same XPath, and you want to target a specific one.

Syntax:

Example:

Chained XPath in Selenium

Chained XPath helps navigate through nested elements.

Syntax:

Example:

Pro Tip: Use contains(), starts-with(), text(), and logical operators to handle dynamic or complex elements. Always test your XPath in browser DevTools before using it in Selenium.

How to Write XPath Using Axes?

XPath axes come in handy when the exact element TagName or its attribute value is dynamic and cannot be used to locate an element. In such cases, locating elements by traversing through child/sibling or parent elements becomes easy.

Some of the widely used XPath axes are:

following

It can be used when you have a unique attribute of the tag before your actual WebElement. For example, using the following axis, you can have all the elements that follow the current node, and you can simply use Index or another chained XPath to locate your actual WebElement.

Syntax:

Example:

following-sibling

Siblings are those nodes that share the same parent or are at the same level. Hence, the following-sibling axis will return you to the node at the same level and after the current node.

Syntax:

Example:

preceding

The preceding axis locate all the elements before the current node. You can retrieve all the elements preceding the current node, and with an index or another chained XPath expression, you can pinpoint the specific WebElement you are looking for.

Syntax:

Example:

preceding-sibling

The preceding-sibling axis retrieves all nodes that are siblings or at the same level but appear before the current node.

Syntax:

Example:

child

It is used to locate child elements of a particular node. A common use case for this approach is to iterate through the data in a table by navigating through its rows.

Syntax:

Example:

parent

It is used to select the parent node of the current node in an XML or HTML document. This axis allows you to navigate from a specific element to its immediate parent.

Syntax:

Example:

descendant

It is used to select all the descendants of the current node in an XML or HTML document. In this context, descendants encompass not only immediate child nodes but also include grandchild nodes, great-grandchild nodes, and so forth.

Syntax:

Example:

ancestor

It is used for selecting the ancestors of the current node. In this context, ancestors refer to the parent nodes, grandparent nodes, and so forth.

Syntax:

Example:

How to Create a Dynamic XPath in Selenium?

A dynamic XPath helps you locate such elements without rewriting the locator each time something changes. These XPath expressions are flexible and adapt to shifting attributes, positions, or DOM structures.

You can build dynamic XPath expressions using the following techniques:

Functions

Functions such as contains(), starts-with(), and text() help match elements based on partial attribute values or visible text.

Example – contains():

Example – starts-with():

Example – text():

Logical Operators

You can combine multiple conditions (and/or) to make your XPath more robust.

Example:

XPath Axes

You can use DOM relationships to find elements based on their position relative to other known elements.

Example:

Other useful axes:

• following / following-sibling
• preceding / preceding-sibling
• child, parent, ancestor, descendant

Indexing for Repeating Elements

You can use position to differentiate when multiple elements match the same XPath.

Example:

Wildcards (*) for Flexible Tag Selection

If you’re unsure about the tag name, use an asterisk * to match any element type.

Syntax:

Example:

How to Capture the XPath of Loader Images?

While performing automation testing with Selenium, you may encounter WebElements that appear only for a short time. Writing XPath for such transient or dynamic elements, like loading images can be challenging.

Below is a screen capture from X (Formerly Twitter) illustrating a loader image. Let us demonstrate how to capture the XPath for this image:

1. As soon as the page opens, press F12 to be ready to inspect the element. Switch to the Sources tab, as highlighted in the below image.



2. When the loading symbol appears on your screen, press F8 or click on the image highlighted below.



This will pause the execution, and you will see a notification badge like below on top of your screen.



3. Now, you can return to the Elements tab and start identifying and writing the locator.
//div[@aria-label='Loading']

1	//div[@aria-label='Loading']



4. Go back to the Sources tab and click on the resume icon as shown below.

This way, you can simply pause the execution and let the element be on your screen till you identify the locator.

Pro-Tip: To learn more about XPath, follow this XPath locator cheat sheet to learn and use all the various ways of locating WebElement efficiently, making your automation testing process faster.

How LambaTest Online Selenium Grid Ensures Effective Test Automation?

LambdaTest is a GenAI-native test execution platform that offers scalable online Selenium Grid to execute Selenium automation tests across thousands of real browser and operating system combinations on demand.

You can run Selenium tests without maintaining any local infrastructure. This approach significantly streamlines setup, accelerates cross‑browser coverage, and reduces overall test execution time.

To get started, check out this guide on Selenium testing with LambdaTest.

Features:

• Parallel Test Execution at Scale: Execute hundreds of Selenium tests concurrently across multiple browsers and operating systems to drastically reduce testing time. Ideal for large test suites.
• Comprehensive Debugging with Logs & Video Playback: Capture full execution details – Selenium logs, network logs, step-by-step screenshots, and video recordings to debug faster and build reliable bug reports.
• Test Insights: Leverage GenAI-native test insights to gain visibility into test trends with an interactive dashboard that shows execution timelines, pass/fail rates, environment breakdowns, and more.
• CI/CD Integration: Integrate effortlessly with tools like Jenkins, GitHub Actions, Azure DevOps for seamless test automation.

Best Practices for Using XPath in Selenium

To write stable and efficient Selenium scripts, using XPath the right way is crucial.

Below are key best practices that you can follow to handle XPath efficiently.

• Prefer Relative XPath Over Absolute XPath: Use relative XPath (//) instead of absolute paths (/html/body/…) to make your locators more resilient to UI changes.
• Use Unique Attributes: Target attributes like id, name, or custom data-* when available to create stable and specific locators.
• Use contains() for Partial Matching: When dealing with dynamic attribute values, use the contains() function to match partial values.
• Use text() to Match Visible Text: If the element’s visible text is consistent and unique, use the text() function to locate it.
• Combine Multiple Conditions: Make your XPath more specific by combining conditions using and or or.
• Use starts-with() for Matching Dynamic Prefixes: For attributes that begin with a consistent prefix, use the starts-with() function.
• Avoid Index-Based XPath When Possible: Using indexes like (//div[@class=’item’])[3] is fragile. DOM changes can break your test.
• Use XPath Axes When Necessary: Axes like following-sibling::, parent::, or ancestor:: help target elements in complex DOMs.
• Keep XPath Short and Readable: Write concise expressions that are easy to read and maintain. Avoid deeply nested or overly complex paths.
• Validate XPath Using Browser DevTools: Use tools like XPath tester or Chrome DevTools with $x(“your_xpath”) to test and validate XPath expressions before using them in scripts.
• Leverage Custom Data Attributes: Prefer data-testid, data-role, or other data-* attributes as they are designed for automation.

• Write Contextual Locators: Use nearby stable elements, like labels, to anchor your XPath reliably.

Common XPath Issues and How to Troubleshoot?

Here are some common XPath issues in Selenium and how to troubleshoot them.

• Invalid or Malformed XPath: Syntax errors like missing brackets, unclosed quotes, wrong axes, or stray characters.
  

Fix: Use browser DevTools or tools like SelectorsHub to validate and correct your XPath.

• XPath Matches Nothing: The element may not be present in the live DOM (e.g., inside iFrame, Shadow DOM, or is loaded dynamically).
  

Fix: Check for iframes using browser DevTools. Use JavaScript like document.querySelector or $x() in console. Add proper waits using WebDriverWait.

• XPath Returns Multiple Elements: The XPath is too broad or lacks specific filters.
  

Fix: Use indexes like (//div[@class=’item’])[1] or add more conditions such as //div[@class=’item’ and @data-id=’123′].

• Dynamic Attributes (IDs, Classes): Attributes change between sessions or page loads.
  

Fix: Use partial match functions like contains() or starts-with(). Example: //div[contains(@class, ‘btn’)].

• Element Inside Shadow DOM or Custom Elements: Standard XPath can’t access elements inside shadow DOM.
  

Fix: Use JavaScript like element.shadowRoot.querySelector(). Consider tools like Playwright which handle shadow DOM better.

• XPath Works in Browser but Not in Code: Possible timing issue or unhandled frame context.
  

Fix: Wait for elements using explicit waits. Make sure to switch to the correct iframe using driver.switchTo().frame(…).

• Case Sensitivity and Typos: XPath is case-sensitive; even small mismatches can break it.
  

Fix: Double-check tag names and attributes. Test XPath directly using $x(‘your_xpath’) in browser console.

Conclusion

You’ve now seen how XPath works in Selenium, from the basics to advanced techniques like axes and dynamic locators. We also looked at how to handle specific elements like loaders and how to follow best practices for writing reliable XPath expressions.

To scale your automation, you can use LambdaTest online Selenium Grid. It helps you run tests in parallel, debug faster, and cover multiple browser-OS combinations without managing infrastructure.

Now that you’ve seen how XPath works, you might also want to explore how it differs from CSS selectors. You can this comparison guide on XPath vs CSS Selectors to know more.

Citations

• XPath Wikipedia: https://en.wikipedia.org/wiki/XPath