XPath stands for XML Path Language. In Selenium WebDriver, XPath is a powerful locator strategy used to identify and interact with web elements in an HTML DOM. XPath can locate elements using attributes, text, relationships between elements, indexes, and different axes.
XPath is especially useful when an element does not have a unique ID, Name, or Class Name, or when the tester needs to create a more flexible locator for dynamic web applications. Selenium WebDriver supports XPath through the By.xpath() method.
XPath is included among the locator strategies covered in Selenium training, along with ID and CSS selectors, and is used for locating web elements in practical browser automation. JustAcademy's Selenium Training Course also covers Selenium WebDriver, locators, web elements, forms, browser interactions, waits, and automation frameworks.
For course demonstration and registration information, visit the Register for Course Demo page.
XPath is a query language used to navigate through elements and attributes in an XML or HTML document. Selenium uses XPath expressions to locate elements in the DOM.
For example, consider:
<input id="username" name="username" type="text">An XPath locator for this element can be:
//input[@id='username']Selenium code:
driver.findElement(
By.xpath("//input[@id='username']")
);
XPath is important because modern web applications often contain complex and dynamic DOM structures. Simple locators may not always be sufficient to identify the required element.
The most common XPath syntax is:
//tagname[@attribute='value']Example:
//input[@name='username']Another example:
//button[@type='submit']Selenium uses the By.xpath() method to locate an element.
driver.findElement(
By.xpath("//input[@id='username']")
);
The general structure is:
driver.findElement(By.xpath("XPATH_EXPRESSION"));import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class XPathExample {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
driver.manage().window().maximize();
driver.get("https://example.com");
driver.findElement(
By.xpath("//input[@id='username']")
).sendKeys("admin");
driver.quit();
}
}
XPath works with the DOM structure of a web page. The browser converts HTML into a tree-like structure containing elements, attributes, text nodes, and relationships.
HTML
|
+-- BODY
|
+-- FORM
|
+-- INPUT
|
+-- INPUT
|
+-- BUTTON
XPath allows Selenium to navigate this structure and identify a specific element.
An Absolute XPath starts from the root of the HTML document and specifies the complete path to an element.
/html/body/div/form/inputAbsolute XPath can become fragile because even a small change in the DOM structure can make the locator invalid.
A Relative XPath usually starts with // and searches for an element based on its characteristics rather than describing the complete path from the root.
//input[@id='username']Relative XPath is generally easier to maintain because it does not depend on the complete DOM hierarchy.
| Feature | Absolute XPath | Relative XPath |
|---|---|---|
| Starts with | / | // |
| DOM dependency | High | Lower |
| Maintenance | Can be difficult | Generally easier |
| Flexibility | Limited | High |
| Typical usage | Specific full path | Practical automation locators |
Suppose the HTML is:
<input id="username" type="text">XPath:
//input[@id='username']Selenium:
driver.findElement(
By.xpath("//input[@id='username']")
).sendKeys("admin");
<input name="email" type="email">XPath:
//input[@name='email']Selenium:
driver.findElement(
By.xpath("//input[@name='email']")
).sendKeys("[email protected]");
<button class="login-button">Login</button>XPath:
//button[@class='login-button']<input type="password">XPath:
//input[@type='password']<input type="submit" value="Login">XPath:
//input[@value='Login']<input placeholder="Enter Username" type="text">XPath:
//input[@placeholder='Enter Username']Multiple attributes can be combined using the and operator.
//input[@type='text' and @name='username']Another example:
//input[@type='text' and @name='username' and @placeholder='Enter Username']The or operator can be used when either of multiple conditions can identify the element.
//input[@id='username' or @name='username']This XPath matches an input whose ID is username or whose name is username.
The text() function is useful for locating elements based on their exact visible text.
<button>Login</button>XPath:
//button[text()='Login']Selenium:
driver.findElement(
By.xpath("//button[text()='Login']")
).click();
The contains() function is useful when only part of the text is stable.
<button>Login to Account</button>XPath:
//button[contains(text(),'Login')]The contains() function can be used with attributes as well as text.
Attribute example:
//input[contains(@id,'user')]Text example:
//button[contains(text(),'Login')]Class example:
//div[contains(@class,'container')]The starts-with() function identifies elements whose attribute value or text starts with a specified value.
//input[starts-with(@id,'user_')]This is useful for dynamic IDs such as:
user_12345
user_93842
user_84729
The normalize-space() function removes leading and trailing whitespace and normalizes consecutive whitespace characters.
//button[normalize-space()='Login']This can be useful when HTML contains unexpected spaces around visible text.
//button[contains(normalize-space(),'Login')]//input[@type='text' and @name='username']Both conditions must match.
//input[@id='username' or @name='username']At least one condition must match.
The not() function can exclude elements matching a particular condition.
//input[not(@type='hidden')]This selects input elements that do not have type equal to hidden.
//button[contains(@class,'btn') and contains(@class,'login')]XPath supports indexes for selecting a particular matching element.
(//input[@type='text'])[1]Second matching element:
(//input[@type='text'])[2]<input type="text" name="first">
<input type="text" name="second">
<input type="text" name="third">
First input:
(//input[@type='text'])[1]Second input:
(//input[@type='text'])[2]The position() function can be used to identify an element based on its position.
//input[@type='text'][position()=1]Second element:
//input[@type='text'][position()=2]The last() function identifies the last matching element.
//input[@type='text'][last()]The parent axis selects the parent of the current element.
//input[@id='username']/parent::divThe .. notation can be used to move to the parent element.
//input[@id='username']/..The child axis selects child elements.
//div[@id='login']/child::inputEquivalent shorter form:
//div[@id='login']/inputThe descendant axis selects elements located anywhere below the current element.
//div[@id='login']/descendant::inputShorter form:
//div[@id='login']//inputThe ancestor axis selects ancestor elements of the current element.
//input[@id='username']/ancestor::formThe following-sibling axis selects siblings that appear after the current element.
//label[text()='Username']/following-sibling::inputThe preceding-sibling axis selects siblings that appear before the current element.
//input[@id='username']/preceding-sibling::labelThe following axis selects elements appearing later in the document, excluding descendants.
//label[text()='Username']/following::inputThe preceding axis selects elements appearing before the current element.
//input[@id='password']/preceding::labelThe self axis refers to the current node.
//input[@id='username']/self::input//div[@id='container']/descendant-or-self::div//input[@id='username']/ancestor-or-self::input| Axis | Purpose |
|---|---|
| ancestor | Selects ancestors |
| ancestor-or-self | Selects ancestors and current node |
| attribute | Selects attributes |
| child | Selects direct children |
| descendant | Selects descendants |
| descendant-or-self | Selects descendants and current node |
| following | Selects nodes later in the document |
| following-sibling | Selects following siblings |
| parent | Selects parent |
| preceding | Selects preceding nodes |
| preceding-sibling | Selects preceding siblings |
| self | Selects current node |
<div class="login-form">
<input name="username">
</div>
XPath:
//div[@class='login-form']/input[@name='username']<div class="container">
<div class="form">
<input name="email">
</div>
</div>
XPath:
//div[@class='container']//input[@name='email']<label>Username</label>
<input type="text" name="username">
XPath:
//label[text()='Username']/following-sibling::input//form[@id='registration']//input[@name='email']This identifies an email field within a specific registration form.
//button[@type='submit']Using text:
//button[text()='Submit']Using partial text:
//button[contains(text(),'Submit')]//a[@href='/login']Using text:
//a[text()='Login']Using partial text:
//a[contains(text(),'Login')]//input[@type='checkbox' and @name='terms']Selenium:
WebElement checkbox = driver.findElement(
By.xpath("//input[@type='checkbox' and @name='terms']")
);
if (!checkbox.isSelected()) {
checkbox.click();
}
//input[@type='radio' and @value='male']Selenium:
driver.findElement(
By.xpath("//input[@type='radio' and @value='male']")
).click();
<select id="country">
<option value="india">India</option>
<option value="usa">USA</option>
</select>
Select element:
//select[@id='country']India option:
//select[@id='country']/option[@value='india']<img src="/images/logo.png" alt="Company Logo">XPath:
//img[@alt='Company Logo']<table id="users">
<tr>
<td>John</td>
<td>[email protected]</td>
</tr>
</table>
Table:
//table[@id='users']Rows:
//table[@id='users']//trCells:
//table[@id='users']//tr//tdSuppose a table contains product names:
<table id="products">
<tr>
<td>Laptop</td>
<td>1000</td>
</tr>
<tr>
<td>Phone</td>
<td>700</td>
</tr>
</table>
Row containing Laptop:
//table[@id='products']//tr[td[text()='Laptop']]//table[@id='products']//tr[td[text()='Laptop']]//buttonThis is useful for actions such as Edit, Delete, View, or Add to Cart for a specific table row.
Suppose an application generates:
<input id="user_847392">If the stable portion is user_, use:
//input[starts-with(@id,'user_')]Or:
//input[contains(@id,'user_')]<button class="btn-submit-8392">Submit</button>XPath:
//button[contains(@class,'btn-submit')]//input[contains(@class,'form-control') and @name='email']Combining stable attributes can reduce the chance of matching the wrong element.
Suppose the text is:
Welcome, JohnA partial text XPath can be:
//div[contains(text(),'Welcome')]For whitespace variations:
//div[contains(normalize-space(),'Welcome')]<button> Login </button>Instead of depending on the exact whitespace:
//button[normalize-space()='Login']//input[contains(@placeholder,'Username')]//a[starts-with(@href,'/products')]This can identify links whose href starts with a known path.
When several elements match the same XPath, Selenium's findElement() returns the first matching element according to the WebDriver element search.
driver.findElement(
By.xpath("//button[@class='btn']")
);
If you need all matching elements, use findElements().
List<WebElement> buttons = driver.findElements(
By.xpath("//button")
);
List<WebElement> links = driver.findElements(
By.xpath("//a")
);
System.out.println(
"Number of links: " + links.size()
);
List<WebElement> links = driver.findElements(
By.xpath("//nav//a")
);
for (WebElement link : links) {
System.out.println(link.getText());
}
WebDriverWait wait =
new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement loginButton = wait.until(
ExpectedConditions.elementToBeClickable(
By.xpath("//button[@type='submit']")
)
);
loginButton.click();
import java.time.Duration;
import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
WebElement dashboard = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.xpath("//div[@id='dashboard']")
)
);
WebElement element = wait.until(
ExpectedConditions.presenceOfElementLocated(
By.xpath("//input[@name='username']")
)
);
WebElement button = wait.until(
ExpectedConditions.elementToBeClickable(
By.xpath("//button[contains(text(),'Login')]")
)
);
button.click();
driver.manage().timeouts().implicitlyWait(
Duration.ofSeconds(10)
);
After configuring the wait, XPath can be used normally with findElement().
Dynamic applications may generate changing IDs, classes, text, and DOM structures. XPath functions such as contains(), starts-with(), and normalize-space() can help create more flexible locators.
//input[contains(@id,'user')]
//button[contains(@class,'submit')]
//div[normalize-space()='Login']
<form id="loginForm">
<input name="username" type="text">
<input name="password" type="password">
<button type="submit">Login</button>
</form>
Username:
//form[@id='loginForm']//input[@name='username']Password:
//form[@id='loginForm']//input[@name='password']Login button:
//form[@id='loginForm']//button[@type='submit']driver.findElement(
By.xpath("//input[@name='username']")
).sendKeys("admin");
driver.findElement(
By.xpath("//input[@name='password']")
).sendKeys("admin123");
driver.findElement(
By.xpath("//button[@type='submit']")
).click();
driver.findElement(
By.xpath("//input[@name='firstName']")
).sendKeys("John");
driver.findElement(
By.xpath("//input[@name='lastName']")
).sendKeys("Smith");
driver.findElement(
By.xpath("//input[@type='email']")
).sendKeys("[email protected]");
driver.findElement(
By.xpath("//input[@type='password']")
).sendKeys("Password123");
driver.findElement(
By.xpath("//button[@type='submit']")
).click();
<div class="product-card">
<h3>Laptop</h3>
<button>Add to Cart</button>
</div>
Product:
//div[contains(@class,'product-card')][.//h3[text()='Laptop']]Add to Cart button for Laptop:
//div[contains(@class,'product-card')][.//h3[text()='Laptop']]//button[contains(text(),'Add to Cart')]//nav//a[@href='/courses']Using text:
//nav//a[normalize-space()='Courses']<div id="loginModal" class="modal">
<input name="username">
</div>
Username inside modal:
//div[@id='loginModal']//input[@name='username']<div class="alert-success">Login successful</div>XPath:
//div[contains(@class,'alert-success')]Using text:
//div[contains(text(),'Login successful')]//div[contains(@class,'error-message')]Or:
//div[contains(normalize-space(),'Invalid password')]XPath can locate a checkbox using its attributes. Selenium's isSelected() method is normally used to verify its current state.
WebElement checkbox = driver.findElement(
By.xpath("//input[@type='checkbox' and @name='terms']")
);
if (checkbox.isSelected()) {
System.out.println("Checkbox is selected");
}
WebElement radio = driver.findElement(
By.xpath("//input[@type='radio' and @value='male']")
);
if (radio.isSelected()) {
System.out.println("Male radio button is selected");
}
For HTML form controls, XPath can sometimes be used with attributes such as @checked, but the presence of the attribute and the current DOM state are not always interchangeable. Selenium's isSelected() method is the preferred way to verify the current selected state.
//button[@disabled]Selenium can then verify whether the element is enabled:
WebElement button = driver.findElement(
By.xpath("//button[@disabled]")
);
System.out.println(button.isEnabled());
//input[@required]//button[@data-testid='login-button']Data attributes can provide stable locator values when they are intentionally designed for automation or testing.
<button data-testid="submit-button">Submit</button>XPath:
//button[@data-testid='submit-button']<button aria-label="Search">🔍</button>XPath:
//button[@aria-label='Search']Angular applications may expose attributes such as formcontrolname.
//input[@formcontrolname='email']React applications may contain dynamically generated class names. Stable attributes such as data-testid, aria-label, or application-specific attributes can sometimes provide more maintainable XPath expressions.
//button[@data-testid='login-button']Suppose the table contains:
John
Smith
Active
A row containing the email can be located using:
//table[@id='users']//tr[td[contains(text(),'[email protected]')]]//table[@id='users']//tr[td[contains(text(),'[email protected]')]]//button[contains(text(),'Edit')]This technique is useful when every row contains similar Edit or Delete buttons.
The dot . represents the current context node in XPath expressions.
//div[contains(@class,'product')][.//h3[text()='Laptop']]Here the dot refers to the current product element while checking its descendant heading.
//div[.//span[normalize-space()='Laptop']]This locates a div containing a descendant span with the specified text.
//div[contains(@class,'product') and .//h3[contains(text(),'Laptop')]]//div[@class='card']//div[@class='actions']//buttonSometimes an element can be identified through a unique child.
//div[.//input[@name='username']]This selects a div containing the username input.
//input[@name='username']/ancestor::formThis locates the form containing the username field.
//label[normalize-space()='Password']/following-sibling::inputThis is useful when the label text is stable but the input does not have a useful unique attribute.
//label[normalize-space()='Username']/following-sibling::input[1]//div[@id='loginForm']//input[@name='username']This restricts the search to a particular parent container.
//form[@id='loginForm']//input[@name='username']This is safer than using a generic selector such as:
//input[@name='username']when multiple username fields may exist on the page.
//ul[@id='menu']/li[2]This selects the second direct li child.
(//button[contains(@class,'submit')])[1](//button[contains(@class,'submit')])[last()]//button[not(@disabled)]This identifies buttons that do not contain a disabled attribute.
WebElement username = driver.findElement(
By.xpath("//input[@name='username']")
);
username.sendKeys("admin");
List<WebElement> buttons = driver.findElements(
By.xpath("//button")
);
for (WebElement button : buttons) {
System.out.println(button.getText());
}
XPath locators can be stored inside Page Object classes for better organization and maintainability.
public class LoginPage {
private WebDriver driver;
private By username =
By.xpath("//input[@name='username']");
private By password =
By.xpath("//input[@name='password']");
private By loginButton =
By.xpath("//button[@type='submit']");
public LoginPage(WebDriver driver) {
this.driver = driver;
}
public void login(String user, String pass) {
driver.findElement(username).sendKeys(user);
driver.findElement(password).sendKeys(pass);
driver.findElement(loginButton).click();
}
}
public WebElement findByXPath(String xpath) {
return driver.findElement(
By.xpath(xpath)
);
}
Usage:
findByXPath("//input[@name='username']")
.sendKeys("admin");
public void clickByXPath(String xpath) {
driver.findElement(
By.xpath(xpath)
).click();
}
public void typeByXPath(String xpath, String text) {
driver.findElement(
By.xpath(xpath)
).sendKeys(text);
}
import org.testng.Assert;
import org.testng.annotations.Test;
@Test
public void verifyLoginButton() {
WebElement button = driver.findElement(
By.xpath("//button[@type='submit']")
);
Assert.assertTrue(button.isDisplayed());
}
WebElement message = driver.findElement(
By.xpath("//div[contains(@class,'success-message')]")
);
Assert.assertTrue(message.isDisplayed());
If Selenium cannot find an element using the supplied XPath, NoSuchElementException may occur.
Common reasons include:
If the XPath expression is syntactically invalid, Selenium may throw an InvalidSelectorException.
Example of a valid XPath:
//input[@id='username']Always verify complex XPath expressions in browser developer tools before adding them to automation code.
A previously located element can become stale if the page refreshes or the DOM element is replaced.
A common solution is to locate the element again rather than continuing to use an outdated WebElement reference.
If another element overlays the target, Selenium may not be able to click it even when the XPath is correct.
Possible solutions include:
If an element is inside an iframe, Selenium must first switch into the iframe.
driver.switchTo().frame("loginFrame");
driver.findElement(
By.xpath("//input[@name='username']")
).sendKeys("admin");
driver.switchTo().defaultContent();
driver.switchTo().frame("outerFrame");
driver.switchTo().frame("innerFrame");
driver.findElement(
By.xpath("//input[@id='username']")
).sendKeys("admin");
driver.switchTo().defaultContent();
XPath does not automatically cross a Shadow DOM boundary. If the target element exists inside a shadow root, Selenium must first access the shadow root and then locate the element within that context using supported Shadow DOM APIs.
SVG elements can require special attention because their namespace and DOM structure can differ from ordinary HTML elements.
For example:
//*[name()='svg']For a specific SVG element, inspect the actual DOM structure and create a locator based on stable attributes.
| Feature | XPath | CSS Selector |
|---|---|---|
| Method | By.xpath() | By.cssSelector() |
| ID matching | Supported | Supported |
| Class matching | Supported | Supported |
| Attribute matching | Supported | Supported |
| Text matching | Strong | More limited |
| Parent navigation | Strong | Different model |
| Sibling navigation | Strong | Supported |
| Complex DOM relationships | Highly expressive | Expressive but different |
| Partial attribute matching | contains(), starts-with() | *, ^=, $= |
| Feature | ID | XPath |
|---|---|---|
| Method | By.id() | By.xpath() |
| Syntax | Simple | More expressive |
| Attributes | ID only | Multiple attributes |
| Relationships | No | Yes |
| Text | No | Yes |
data-testid or similar test attributes when intentionally provided by the application.contains() for stable portions of dynamic attributes.starts-with() when the beginning of an attribute is stable.normalize-space() when whitespace can vary.Avoid locators such as:
/html/body/div[2]/div[1]/form/div[3]/inputA more maintainable locator may be:
//form[@id='loginForm']//input[@name='username']Instead of:
(//button)[7]Prefer a stable locator:
//button[@type='submit' and normalize-space()='Login']Indexes can be useful when the DOM genuinely requires positional selection, but they should not be the first choice when a stable attribute is available.
Browsers provide developer tools that can be used to inspect the DOM and test XPath expressions.
Open Web Page
↓
Right Click Element
↓
Select Inspect
↓
Understand DOM Structure
↓
Identify Stable Attributes
↓
Create XPath
↓
Test XPath
↓
Use XPath in Selenium
↓
Validate Automation
XPath can be tested in browser developer tools using document.evaluate().
document.evaluate(
"//input[@id='username']",
document,
null,
XPathResult.FIRST_ORDERED_NODE_TYPE,
null
).singleNodeValue;
This helps verify whether an XPath identifies the intended element before implementing it in Selenium.
driver.get("https://example.com/login");
driver.findElement(
By.xpath("//input[@name='username']")
).sendKeys("admin");
driver.findElement(
By.xpath("//input[@name='password']")
).sendKeys("admin123");
driver.findElement(
By.xpath("//button[@type='submit']")
).click();
driver.findElement(
By.xpath("//input[@name='firstName']")
).sendKeys("John");
driver.findElement(
By.xpath("//input[@name='lastName']")
).sendKeys("Smith");
driver.findElement(
By.xpath("//input[@name='email']")
).sendKeys("[email protected]");
driver.findElement(
By.xpath("//input[@name='password']")
).sendKeys("Password123");
driver.findElement(
By.xpath("//button[contains(normalize-space(),'Register')]")
).click();
driver.findElement(
By.xpath("//h3[normalize-space()='Laptop']")
);
driver.findElement(
By.xpath("//div[contains(@class,'product-card')][.//h3[normalize-space()='Laptop']]//button[contains(normalize-space(),'Add to Cart')]")
).click();
List<WebElement> rows = driver.findElements(
By.xpath("//table[@id='users']//tbody//tr")
);
for (WebElement row : rows) {
System.out.println(row.getText());
}
WebElement editButton = driver.findElement(
By.xpath(
"//table[@id='users']//tr[td[normalize-space()='[email protected]']]//button[contains(normalize-space(),'Edit')]"
)
);
editButton.click();
driver.findElement(
By.xpath("//nav//a[normalize-space()='Courses']")
).click();
WebElement terms = driver.findElement(
By.xpath("//input[@type='checkbox' and @name='terms']")
);
if (!terms.isSelected()) {
terms.click();
}
WebElement male = driver.findElement(
By.xpath("//input[@type='radio' and @value='male']")
);
if (!male.isSelected()) {
male.click();
}
driver.findElement(
By.xpath("//select[@id='country']")
);
driver.findElement(
By.xpath("//select[@id='country']/option[@value='india']")
).click();
Launch Browser
↓
Open Application
↓
Inspect DOM
↓
Identify Stable Attributes
↓
Create XPath
↓
Validate XPath
↓
Use By.xpath()
↓
Locate WebElement
↓
Perform Action
↓
Validate Result
↓
Continue Test
↓
Close Browser
| Requirement | XPath |
|---|---|
| ID | //input[@id='username'] |
| Name | //input[@name='username'] |
| Class | //button[@class='login-button'] |
| Attribute | //input[@type='text'] |
| Multiple Attributes | //input[@type='text' and @name='username'] |
| Exact Text | //button[text()='Login'] |
| Partial Text | //button[contains(text(),'Login')] |
| Contains Attribute | //input[contains(@id,'user')] |
| Starts With | //input[starts-with(@id,'user_')] |
| Normalized Text | //button[normalize-space()='Login'] |
| Parent | //input[@id='username']/parent::div |
| Child | //div[@id='login']/child::input |
| Descendant | //div[@id='login']//input |
| Ancestor | //input[@id='username']/ancestor::form |
| Following Sibling | //label/following-sibling::input |
| Preceding Sibling | //input/preceding-sibling::label |
| First Match | (//button)[1] |
| Last Match | (//button)[last()] |
| Not | //input[not(@type='hidden')] |
XPath is a language used to navigate XML and HTML DOM structures and identify specific nodes. Selenium uses XPath expressions to locate web elements.
Absolute XPath starts from the root and describes the complete path, while relative XPath generally starts with // and identifies elements using attributes, text, relationships, or other conditions.
By.xpath()driver.findElement(
By.xpath("//input[@id='username']")
);
driver.findElement(
By.xpath("//button[text()='Login']")
);
driver.findElement(
By.xpath("//button[contains(text(),'Login')]")
);
contains() is used to match a substring within an attribute value or text.
starts-with() identifies elements whose selected attribute or text starts with a specified value.
It normalizes whitespace and is useful when text contains unwanted leading, trailing, or repeated spaces.
//input[@id='username']/parent::div//div[@id='login']/child::input//label/following-sibling::input(//button)[last()]//input[starts-with(@id,'user_')]Yes.
driver.findElements(
By.xpath("//button")
);
Yes. Functions such as text() and normalize-space() can be used.
A single slash is used for a direct path step, while // is commonly used to search through descendants from the current context or document.
Yes. Functions such as contains(), starts-with(), and stable attribute combinations can help identify dynamic elements.
No. Selenium must first switch into the iframe context before locating elements inside it.
No. The appropriate shadow root context must be accessed before locating elements inside it.
contains() for stable partial values.starts-with() for predictable dynamic prefixes.normalize-space() when whitespace varies.XPath is one of the most powerful locator strategies available in Selenium WebDriver. It allows automation testers to identify elements using IDs, names, classes, attributes, visible text, partial values, indexes, parent-child relationships, sibling relationships, and advanced XPath axes.
A maintainable XPath should generally rely on stable attributes and meaningful relationships rather than fragile absolute DOM paths or unnecessary indexes. Functions such as contains(), starts-with(), and normalize-space() are especially useful when working with dynamic web applications.
XPath becomes even more useful when combined with Selenium concepts such as WebElement methods, explicit waits, Page Object Model, TestNG, dynamic element handling, frames, forms, tables, and real-world automation projects.
For structured learning of Selenium WebDriver, XPath, CSS Selectors, Web Elements, browser automation, waits, TestNG, Page Object Model, and practical automation testing, explore the JustAcademy's Selenium Training Course.
To explore the available course demonstration and registration options, visit the Register for Course Demo page.
