Download XPath Cheat Sheet PDF for Quick References

XPath is the most flexible locator strategy in Selenium. When element IDs are dynamic, class names are shared, or the DOM structure is complex, XPath gives you the precision to target exactly what you need. This cheat sheet covers everything from basic syntax to advanced axes, operators, string functions, and real-world patterns for test automation.

Quick Reference: Jump to a Section

• XPath Syntax and Path Expressions
• Absolute vs. Relative XPath
• Predicates and Indexing
• Wildcards and Multi-Path Selection
• XPath Axes
• Operators
• String and Math Functions
• Selectors
• Dynamic XPath Strategies
• Using XPath in Selenium
• Testing XPath in Browser DevTools
• XPath vs. CSS Selectors
• Common XPath Mistakes
• XPath with jQuery

XPath Syntax and Path Expressions

XPath (XML Path Language) uses a path-like syntax to identify and navigate nodes in XML and HTML documents. In Selenium, you use XPath to locate WebElements in the DOM.

The standard syntax for an XPath expression in Selenium:

XPath = //tagname[@attribute="value"]

The core path expressions for selecting nodes in an XML or HTML document:

Common Step Expressions

Prefix Expressions

Absolute vs. Relative XPath

You have two ways to locate a WebElement in the DOM: absolute path and relative path.

Absolute XPath

Absolute XPath specifies the complete path from the root element to the target element. It begins with a single forward slash (/), indicating selection from the document root.

/html/body/div[x]/div[y]/

Example:

/html//div/div/div/div[1]/div/a/img

The major downside: any change to the DOM structure breaks the XPath. Avoid absolute paths in production test scripts.

Relative XPath

Relative XPath locates an element based on its position relative to another element rather than the full document path. It begins with a double forward slash (//).

//tagname[@attribute='value']

Relative XPath is the standard choice for Selenium automation. Changes to the page hierarchy outside the targeted element do not break the locator.

Selecting Nodes

Predicates and Indexing

Predicates let you target a specific node within a set. They appear in square brackets and return a boolean (true or false). You can combine them with relational and boolean operators.

Predicate Examples with Attributes

Chaining Order Matters

The order of predicates changes the result. These two expressions are not equivalent:

a[1][@href='/']    // The first anchor, only if it has href='/'
a[@href='/'][1]    // The first anchor that has href='/'

Indexing

Wildcards and Multi-Path Selection

Wildcard Expressions

Multi-Path Selection with the Union Operator

Use the | operator to combine multiple XPath expressions into a single query:

XPath Axes

XPath defines 13 axes that describe the relationship between the current context node and other nodes in the document. Axes let you navigate the DOM tree in any direction from any node.

Syntax:

AxisName::nodetest[predicate]

All 13 Axes

Axis Usage Examples

XPath Operators

XPath expressions can return a number, boolean, node-set, or string. The following operators let you manipulate and evaluate these values.

All Operators

Boolean Operators

String Functions

String functions are among the most useful XPath tools in Selenium, particularly for locating elements with dynamic or partial attribute values.

Math Functions

Node Functions

XPath Selectors

Descendant Selectors

Attribute Selectors

Order Selectors

Sibling Selectors

Contextual Selectors

Other Useful Locator Patterns

Attribute Selector Patterns

Dynamic XPath Strategies

Dynamically generated IDs are one of the most common problems in real-world Selenium automation. When an element has an ID like input_abc123def that changes on every page load, you cannot use an exact attribute match. These patterns handle dynamic attributes reliably.

Partial Attribute Matching

Text-Based Location

Navigating from a Known Anchor

When a target element has no reliable attributes, navigate to it from a stable nearby element:

<!-- Locate a label, then find its associated input -->
//label[text()='Email']/following-sibling::input[1]

<!-- Locate a table row by cell text, then get another cell in the same row -->
//td[text()='John']/parent::tr/td[3]

<!-- Navigate from a section heading to its sibling content -->
//h3[text()='Shipping Address']/following-sibling::div[1]

Using XPath in Selenium

Here is how to use XPath expressions in Selenium WebDriver across the two most common languages.

Python

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

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

# Basic XPath lookup
element = driver.find_element(By.XPATH, "//input[@id='username']")

# Find multiple elements
items = driver.find_elements(By.XPATH, "//ul[@class='results']/li")

# Wait for element before interacting
element = WebDriverWait(driver, 10).until(
    EC.presence_of_element_located((By.XPATH, "//button[text()='Submit']"))
)
element.click()

Java

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
import java.time.Duration;

WebDriver driver = new ChromeDriver();
driver.get("https://example.com");

// Basic XPath lookup
WebElement element = driver.findElement(By.xpath("//input[@id='username']"));

// Find multiple elements
List<WebElement> items = driver.findElements(By.xpath("//ul[@class='results']/li"));

// Wait for element before interacting
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement btn = wait.until(
    ExpectedConditions.presenceOfElementLocated(By.xpath("//button[text()='Submit']"))
);
btn.click();

Testing XPath in Browser DevTools

You can validate any XPath expression directly in Chrome or Firefox DevTools without writing a single line of Selenium code.

Method 1: Elements Panel Search

1. Open DevTools (F12)
2. Go to the Elements tab
3. Press Ctrl+F (Windows/Linux) or Cmd+F (Mac) to open the search bar
4. Type your XPath expression directly into the search bar
5. DevTools highlights all matching elements and shows a count

Method 2: Console with $x()

The $x() function in the browser console evaluates an XPath expression and returns all matching elements as an array:

// Run in the browser console (F12 > Console tab)

// Find all buttons with text "Submit"
$x("//button[text()='Submit']")

// Find input fields with dynamic IDs
$x("//input[contains(@id, 'user')]")

// Count matching elements
$x("//li[@class='active']").length

Method 3: Copy XPath from DevTools

1. Open DevTools (F12)
2. Click the element picker (top-left cursor icon in the DevTools panel)
3. Click the element on the page
4. Right-click the highlighted code in the Elements panel
5. Select Copy > Copy XPath

Note: the copied XPath is usually an absolute path. Treat it as a starting point and rewrite it as a relative expression before adding it to your test scripts.

XPath vs. CSS Selectors

Both XPath and CSS selectors locate elements, but they have different strengths. Understanding the tradeoffs helps you pick the right tool for each situation.

Use CSS selectors for straightforward element selection when you know the class, ID, or tag. Use XPath when you need to traverse upward, match by text, use complex axis relationships, or handle dynamic attributes that CSS substring selectors cannot accommodate as cleanly.

Common XPath Mistakes

These are the patterns most likely to cause brittle tests or unexpected failures in real Selenium projects.

1. Using Absolute XPath

Absolute XPath breaks the moment a developer adds or removes a wrapping element anywhere in the path. Always use relative XPath in test scripts.

<!-- Fragile: breaks if any ancestor changes -->
/html/body/div[2]/div[1]/form/input[1]

<!-- Robust: targets the element by its own attributes -->
//input[@name='email']

2. Index-Based Locators Without a Reliable Anchor

XPath like //div[3] depends entirely on DOM order. Adding a feature that inserts a new div above your target breaks the locator silently.

<!-- Fragile: order-dependent -->
//div[3]

<!-- Robust: select by intent -->
//div[@id='checkout-summary']

3. Whitespace Issues with text()

The text() function matches exact text node content. If the HTML has leading, trailing, or extra internal whitespace, an exact match fails.

<!-- Fails if label renders as "  First Name  " -->
//label[text()='First Name']

<!-- Robust: strips whitespace before matching -->
//label[normalize-space(text())='First Name']

4. Matching Class Attributes Exactly

Using @class='btn' fails when the element has multiple classes like class="btn btn-primary".

<!-- Fails for multi-class elements -->
//button[@class='btn']

<!-- Robust: checks if the class list contains 'btn' -->
//button[contains(@class,'btn')]

5. Case Sensitivity

XPath 1.0 (the version used in most browsers) is case-sensitive. The element <INPUT> does not match //input. HTML documents served in standard mode use lowercase tags, but XML documents may vary. Use translate() if you need case-insensitive matching.

//input[translate(@type,'ABCDEFGHIJKLMNOPQRSTUVWXYZ','abcdefghijklmnopqrstuvwxyz')='submit']

XPath with jQuery

jQuery supports a subset of XPath-style expressions. The table below maps common jQuery traversal methods to their XPath equivalents.

What to Learn Next

XPath gives you precision when simpler locators fall short. The patterns that matter most in day-to-day Selenium work are relative paths with contains() and starts-with() for dynamic attributes, axis navigation for reaching elements without direct identifiers, and text-based targeting with normalize-space() for labels and buttons.

Once you are comfortable with XPath, the logical next step is building maintainable locator strategies into a Page Object Model, which keeps your XPath expressions organized and isolated from test logic.

Browse the top-rated Selenium courses on hackr.io