Absolute XPath is a type of XPath expression used in Selenium WebDriver to locate a specific web element by following the complete hierarchy of elements from the root of the HTML document to the target element. It represents the exact path through the DOM structure and normally starts with a single forward slash (/).
XPath is an important locator technique in Selenium because Selenium WebDriver needs a reliable way to identify and interact with elements such as input fields, buttons, links, forms, tables, checkboxes, and other web elements. JustAcademy's Selenium training curriculum includes locators such as ID, XPath, and CSS selectors as part of Selenium WebDriver and web-element automation. Selenium Training Course
You can also explore the Selenium Course Demo for additional information about Selenium automation training.
Absolute XPath is an XPath expression that identifies a web element by specifying its complete path from the root element of the HTML document to the required element.
For example:
/html/body/div/form/inputThis XPath starts from the HTML root and moves through the body, div, form, and finally reaches the input element.
Absolute XPath follows the complete parent-child hierarchy of the DOM.
The general syntax of Absolute XPath is:
/html/body/parent/child/elementAnother example is:
/html/body/div/form/inputEach element in the path represents a level in the HTML document.
Selenium WebDriver needs a locator to identify the exact web element on which an automation action must be performed. Absolute XPath can be used when the complete DOM hierarchy is known.
It can be used to:
Before learning Absolute XPath, it is important to understand the DOM hierarchy.
HTML
└── BODY
└── DIV
└── FORM
└── INPUT
The corresponding Absolute XPath is:
/html/body/div/form/inputThe XPath follows the hierarchy from the root to the target element.
HTML elements are arranged in a parent-child relationship.
<html>
<body>
<div>
<form>
<input>
</form>
</div>
</body>
</html>
Here:
The Absolute XPath is:
/html/body/div/form/inputAbsolute XPath normally starts with a single forward slash.
/html/body/div/inputThe first slash indicates that XPath navigation starts from the root of the document.
This is different from Relative XPath, which commonly starts with double forward slashes.
//input<html>
<body>
<div>
<form>
<input type="text">
<input type="password">
<button>Login</button>
</form>
</div>
</body>
</html>
Possible Absolute XPath expressions are:
/html/body/div/form/input[1]
/html/body/div/form/input[2]
/html/body/div/form/button
Suppose the webpage contains the following input:
<input type="text">If the element is located inside HTML, body, div, and form, the Absolute XPath can be:
/html/body/div/form/inputSelenium Java example:
driver.findElement(By.xpath("/html/body/div/form/input")).sendKeys("Admin");Consider the following HTML:
<form>
<input type="text">
<input type="password">
</form>
If the password field is the second input element, an Absolute XPath may be:
/html/body/div/form/input[2]Selenium example:
driver.findElement(By.xpath("/html/body/div/form/input[2]")).sendKeys("Password123");Suppose a login button is inside a form:
<form>
<input type="text">
<input type="password">
<button>Login</button>
</form>
The Absolute XPath can be:
/html/body/div/form/buttonSelenium example:
driver.findElement(By.xpath("/html/body/div/form/button")).click();Consider:
<html>
<body>
<div>
<nav>
<a href="/home">Home</a>
</nav>
</div>
</body>
</html>
The Absolute XPath for the Home link can be:
/html/body/div/nav/aSelenium example:
driver.findElement(By.xpath("/html/body/div/nav/a")).click();When multiple elements have the same tag name at the same level, an index can be used.
/html/body/div/form/input[1]This represents the first matching input.
/html/body/div/form/input[2]This represents the second matching input.
/html/body/div/form/input[3]This represents the third matching input.
Indexes help distinguish between multiple elements having the same tag name.
For example:
<form>
<input type="text">
<input type="email">
<input type="password">
</form>
Possible XPath expressions are:
/html/body/form/input[1]
/html/body/form/input[2]
/html/body/form/input[3]
Modern web applications often contain many nested div elements.
<html>
<body>
<div>
<div>
<div>
<button>Submit</button>
</div>
</div>
</div>
</body>
</html>
The Absolute XPath can be:
/html/body/div/div/div/buttonThe XPath follows every level of the DOM hierarchy.
Consider the following structure:
HTML
└── BODY
└── DIV
└── SECTION
└── FORM
└── DIV
└── INPUT
The Absolute XPath is:
/html/body/div/section/form/div/inputThis demonstrates how Absolute XPath can become longer as the DOM hierarchy becomes deeper.
Absolute XPath directly represents the DOM hierarchy of a webpage.
HTML
├── HEAD
└── BODY
├── HEADER
├── MAIN
│ └── DIV
│ └── BUTTON
└── FOOTER
The button may have an Absolute XPath such as:
/html/body/main/div/buttonTables contain several nested elements such as table, tbody, tr, and td.
<table>
<tbody>
<tr>
<td>John</td>
<td>QA Tester</td>
</tr>
</tbody>
</table>
An Absolute XPath for the first table cell may be:
/html/body/table/tbody/tr/td[1]The second table cell may be:
/html/body/table/tbody/tr/td[2]If a table contains multiple rows, an index can be used.
/html/body/table/tbody/tr[1]/td[1]This can represent the first cell of the first row.
/html/body/table/tbody/tr[2]/td[1]This can represent the first cell of the second row.
Browser Developer Tools can help testers inspect the DOM structure of a webpage.
In Chrome:
An XPath can be tested in the browser console using the $x() function.
$x("/html/body/div/form/input")If the XPath is valid and matches an element, Chrome returns the matching element.
This is a useful way to verify an XPath before using it in Selenium code.
Selenium WebDriver uses the By.xpath() method to locate elements using XPath.
WebElement username = driver.findElement(
By.xpath("/html/body/div/form/input[1]")
);
After locating the element, Selenium can perform different operations on it.
The sendKeys() method is used to enter text into an input element.
driver.findElement(
By.xpath("/html/body/div/form/input[1]")
).sendKeys("admin");
The click() method is used to click a web element.
driver.findElement(
By.xpath("/html/body/div/form/button")
).click();
The getText() method retrieves the visible text of an element.
String text = driver.findElement(
By.xpath("/html/body/div/h1")
).getText();
System.out.println(text);
The getAttribute() method retrieves the value of an HTML attribute.
String value = driver.findElement(
By.xpath("/html/body/div/form/input")
).getAttribute("value");
System.out.println(value);
The findElements() method can be used when multiple elements match an XPath expression.
List<WebElement> elements = driver.findElements(
By.xpath("/html/body/div/form/input")
);
System.out.println(elements.size());
<html>
<body>
<div>
<form>
<input type="text">
<input type="password">
<button>Login</button>
</form>
</div>
</body>
</html>
Absolute XPath expressions:
/html/body/div/form/input[1]
/html/body/div/form/input[2]
/html/body/div/form/button
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class AbsoluteXPathExample {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
driver.get("https://example.com/login");
driver.findElement(
By.xpath("/html/body/div/form/input[1]")
).sendKeys("admin");
driver.findElement(
By.xpath("/html/body/div/form/input[2]")
).sendKeys("admin123");
driver.findElement(
By.xpath("/html/body/div/form/button")
).click();
driver.quit();
}
}
| Feature | Absolute XPath | Relative XPath |
|---|---|---|
| Starting Point | Starts from the root | Can start from a selected location |
| Common Syntax | /html/body/div | //div |
| Path | Complete DOM path | Targeted path |
| Length | Usually longer | Usually shorter |
| DOM Dependency | Highly dependent on hierarchy | Can depend on attributes and relationships |
| Maintenance | Can be affected by structural changes | Can be easier to maintain when based on stable attributes |
| Example | /html/body/div/form/input | //input[@id='username'] |
| Feature | Absolute XPath | ID Locator |
|---|---|---|
| Selenium Method | By.xpath() | By.id() |
| Identification | DOM hierarchy | ID attribute |
| Typical Length | Longer | Shorter |
| Dependency | DOM structure | Element ID |
| Example | /html/body/div/form/input | username |
Absolute XPath depends on every element in the path. If any intermediate element changes, the XPath may no longer point to the required element.
Original structure:
html
└── body
└── div
└── form
└── input
XPath:
/html/body/div/form/inputIf another div is inserted:
html
└── body
└── div
└── div
└── form
└── input
The path may become:
/html/body/div/div/form/inputThe original XPath may therefore need to be updated.
Modern applications may dynamically add, remove, or rearrange DOM elements. This can affect Absolute XPath expressions.
For example, a page may initially contain:
/html/body/div/form/inputAfter a UI change, the same element may be located through:
/html/body/div/section/form/inputThis is one reason testers should validate locators whenever the application structure changes.
Indexes are especially sensitive to changes in the number or order of elements.
For example:
/html/body/div/form/input[2]If a new input is inserted before the second input, the required element may become input[3].
Therefore, position-based Absolute XPath expressions should be reviewed carefully when the page contains dynamic content.
In the Page Object Model, locators can be stored as variables inside a page class.
public class LoginPage {
private WebDriver driver;
private By username =
By.xpath("/html/body/div/form/input[1]");
private By password =
By.xpath("/html/body/div/form/input[2]");
private By loginButton =
By.xpath("/html/body/div/form/button");
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();
}
}
Web applications may load elements asynchronously. Selenium can use an explicit wait before interacting with an element.
WebDriverWait wait =
new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement button = wait.until(
ExpectedConditions.elementToBeClickable(
By.xpath("/html/body/div/form/button")
)
);
button.click();
JustAcademy's Selenium curriculum also covers waits, synchronization, dynamic elements, and stable test execution strategies. View Selenium Training
$x("/html/body/div/form/input[1]")Absolute XPath can be useful in situations where:
Absolute XPath should be used carefully when the application has a frequently changing DOM structure.
For example, if a stable ID is available:
driver.findElement(By.id("username"));A relative XPath based on a stable attribute may also be used:
driver.findElement(By.xpath("//input[@id='username']"));The appropriate locator depends on the structure and stability of the application under test.
| Purpose | Example |
|---|---|
| Basic XPath | /html/body/div/input |
| First Input | /html/body/div/input[1] |
| Second Input | /html/body/div/input[2] |
| Nested Input | /html/body/div/form/input |
| Button | /html/body/div/form/button |
| Link | /html/body/div/nav/a |
| Table Cell | /html/body/table/tbody/tr/td |
| Selenium Locator | By.xpath("/html/body/div/input") |
| Chrome Validation | $x("/html/body/div/input") |
Create a simple login page with the following elements:
Inspect the page and create an Absolute XPath for every element.
/html/body/div/form/input[1]
/html/body/div/form/input[2]
/html/body/div/form/button
/html/body/div/form/a
Validate each XPath in Chrome using:
$x("YOUR_XPATH")Open Browser
↓
Open Web Application
↓
Inspect Required Element
↓
Understand DOM Hierarchy
↓
Create Absolute XPath
↓
Validate XPath
↓
Create Selenium Locator
↓
Locate WebElement
↓
Perform Action
↓
Validate Result
↓
Continue Test Execution
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
public class AbsoluteXPathAutomation {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
driver.get("https://example.com/login");
WebElement username = driver.findElement(
By.xpath("/html/body/div/form/input[1]")
);
WebElement password = driver.findElement(
By.xpath("/html/body/div/form/input[2]")
);
WebElement loginButton = driver.findElement(
By.xpath("/html/body/div/form/button")
);
username.sendKeys("admin");
password.sendKeys("admin123");
loginButton.click();
driver.quit();
}
}
Absolute XPath is an XPath expression that identifies an element using its complete path from the root of the HTML document.
It normally starts with a single forward slash (/).
/html/body/div/form/inputAbsolute XPath follows the complete path from the root, while Relative XPath can locate an element using a more targeted expression and commonly starts with //.
Yes. Indexes such as [1], [2], and [3] can be used to identify specific elements among multiple matching elements.
Yes. Selenium WebDriver supports XPath through the By.xpath() locator.
It can break when the DOM hierarchy changes because the XPath depends on the complete path from the root to the target element.
It can be tested using the $x() function in the browser Console.
If elements are added, removed, or reordered, the index may change and the XPath may identify a different element.
Yes. It helps learners understand the DOM tree, parent-child relationships, XPath syntax, and element navigation.
/html/body/div
/html/body/div/form
/html/body/div/form/input
/html/body/div/form/input[1]
/html/body/div/form/input[2]
/html/body/div/form/button
/html/body/div/nav/a
/html/body/table/tbody/tr/td
/html/body/main/div/button
/html/body/div/section/form/input
Absolute XPath is a Selenium locator technique that identifies a web element by following its complete path from the root of the HTML document to the target element. It provides a clear representation of the DOM hierarchy and is useful for understanding how Selenium locates elements.
Absolute XPath can be used with Selenium WebDriver to perform operations such as entering text, clicking buttons, retrieving text, retrieving attributes, and locating multiple elements. However, because it depends on the complete DOM structure, changes in the hierarchy can affect the locator.
Learning Absolute XPath provides a strong foundation for understanding XPath, DOM navigation, web-element identification, and Selenium automation. JustAcademy's Selenium course covers WebDriver, locators, XPath and CSS selectors, dynamic elements, waits, frameworks, TestNG, real-world projects, and other automation-testing concepts. Explore JustAcademy Selenium Training.
For course information and demo registration, visit Register for Selenium Course Demo.
