starts-with() is an XPath function used in Selenium to locate web elements when an attribute value or text begins with a specific string. It is especially useful for handling dynamic web elements where the beginning portion of an attribute remains stable while the remaining portion changes.
XPath is an important locator technique used with Selenium WebDriver. JustAcademy's Selenium training curriculum includes locators such as XPath and CSS selectors as part of Selenium WebDriver and element automation.
For more Selenium learning resources, visit Selenium Training Course and explore the Selenium Course Demo.
The starts-with() function checks whether a string starts with a specified value. In Selenium automation, it can be used to create XPath expressions for elements whose attributes or text begin with a known value.
For example, suppose an input element has a dynamic ID:
<input id="user_12345" type="text">If the numeric portion of the ID changes dynamically but user_ always remains constant, starts-with() can be used:
//input[starts-with(@id,'user_')]This XPath can locate the input element without depending on the complete dynamic ID.
The basic XPath syntax is:
starts-with(string, substring)When used with an HTML attribute:
//tagname[starts-with(@attribute,'value')]Example:
//input[starts-with(@id,'user')]This expression selects an input element whose id attribute starts with user.
| Part | Meaning |
|---|---|
| // | Searches for matching elements anywhere in the document. |
| input | Specifies the HTML element. |
| starts-with() | Checks whether a string starts with a specified value. |
| @id | Refers to the id attribute. |
| 'user' | The expected starting text. |
Modern web applications frequently generate dynamic attribute values. An element may have an ID such as:
user_1001
user_1002
user_1003
The complete ID changes, but the beginning remains the same. Instead of creating separate XPath expressions for every value, starts-with() can identify the common pattern.
//input[starts-with(@id,'user_')]The most common use of starts-with() is locating elements using dynamic IDs.
HTML:
<input id="username_98765" type="text">XPath:
//input[starts-with(@id,'username_')]This XPath matches an input whose ID begins with username_.
The function can also be used with the name attribute.
<input name="user_login_123" type="text">XPath:
//input[starts-with(@name,'user_login_')]This is useful when the name attribute contains a stable prefix and a dynamic suffix.
starts-with() can be applied to the class attribute when the class value has a predictable beginning.
<button class="btn-primary-submit">Submit</button>XPath:
//button[starts-with(@class,'btn-primary')]However, class attributes may contain multiple class names. Therefore, class-based XPath expressions should be created carefully.
The placeholder attribute can also be used.
<input placeholder="Enter your username here" type="text">XPath:
//input[starts-with(@placeholder,'Enter your')]This matches the input because its placeholder starts with Enter your.
starts-with() can technically be used with attributes such as type.
//input[starts-with(@type,'text')]For static values, however, exact matching is generally simpler:
//input[@type='text']starts-with() is most useful when the attribute contains dynamic or variable values.
starts-with() can be used with element text when the visible text begins with a known value.
//button[starts-with(text(),'Login')]Example HTML:
<button>Login to Account</button>The XPath can match the button because its text starts with Login.
Whitespace can sometimes affect text-based XPath expressions. The normalize-space() function can be combined with starts-with() to remove unnecessary leading and trailing whitespace and normalize internal whitespace.
//button[starts-with(normalize-space(text()),'Login')]This is useful when HTML contains extra whitespace around the visible text.
The dot . represents the string value of the current node. It is useful when an element contains nested elements.
//button[starts-with(normalize-space(.),'Login')]Example:
<button>
<span>Login</span>
<span>Now</span>
</button>
Using . can be more reliable than text() when the visible text is distributed across descendant elements.
Consider the following HTML:
<button class="action">
<span>Login</span>
</button>
An XPath using the button's complete string value can be:
//button[starts-with(normalize-space(.),'Login')]This is useful when the target element contains child elements.
Suppose a web application generates IDs such as:
<input id="email_1001">
<input id="email_1002">
<input id="email_1003">
The stable part is email_.
//input[starts-with(@id,'email_')]This XPath can identify elements whose ID begins with the specified prefix.
Suppose a button has:
<button id="submit_78452">Submit</button>Use:
//button[starts-with(@id,'submit_')]The XPath does not depend on the changing numeric suffix.
Suppose links have dynamic href values:
<a href="/products/1001">Product 1</a>
<a href="/products/1002">Product 2</a>
XPath:
//a[starts-with(@href,'/products/')]This can locate links whose href begins with the specified path.
The href attribute is frequently useful for starts-with() when URLs share a common beginning.
//a[starts-with(@href,'https://example.com/products')]This expression targets links whose href starts with the specified URL.
Modern web applications frequently use accessibility attributes such as aria-label.
<button aria-label="Search products">🔍</button>XPath:
//button[starts-with(@aria-label,'Search')]This can be useful when the visible text is unavailable or represented by an icon.
Applications often use custom data attributes for JavaScript and testing.
<button data-testid="login-button-123">Login</button>XPath:
//button[starts-with(@data-testid,'login-button-')]This can be useful when the test ID contains a dynamic suffix.
starts-with() can be combined with other XPath conditions using and.
//input[starts-with(@id,'user_') and @type='text']This selects an input whose ID starts with user_ and whose type is text.
The or operator can be used when more than one starting pattern is acceptable.
//input[starts-with(@id,'user_') or starts-with(@id,'username_')]This XPath matches elements whose ID begins with either prefix.
Always use the most appropriate element type when possible.
//button[starts-with(@id,'submit_')]This is generally more specific than:
//*[starts-with(@id,'submit_')]The second expression searches across all elements and may produce multiple matches.
starts-with() can be combined with parent-child relationships.
//form//input[starts-with(@id,'user_')]This searches for input elements inside a form where the ID starts with user_.
The descendant axis can be used to find matching elements at any level below a parent.
//div[@class='login-form']//input[starts-with(@id,'user_')]This approach helps narrow the search to a specific section of the page.
You can first identify a child element and then navigate to its parent.
//input[starts-with(@id,'username_')]/parent::divThis selects the parent div of an input whose ID starts with username_.
The ancestor axis can be used when the required parent structure is higher in the DOM.
//input[starts-with(@id,'username_')]/ancestor::formThis locates the form containing the matching input.
starts-with() can be combined with sibling relationships.
//label[starts-with(normalize-space(.),'Username')]/following-sibling::inputThis can locate an input that follows a label whose text starts with Username.
It can be used when table cell text begins with a known value.
//tr[td[starts-with(normalize-space(.),'John')]]This finds a table row containing a cell whose text starts with John.
Example:
<option>India - Mumbai</option>
<option>India - Delhi</option>
<option>United States</option>
XPath:
//option[starts-with(normalize-space(.),'India')]This identifies options whose text starts with India.
Suppose search results display names beginning with a known prefix:
<div class="result">Apple iPhone</div>
<div class="result">Apple MacBook</div>
XPath:
//div[@class='result' and starts-with(normalize-space(.),'Apple')]In Selenium Java, the XPath expression is passed to By.xpath().
WebElement username = driver.findElement(By.xpath("//input[starts-with(@id,'username_')]"));
username.sendKeys("admin");
A dynamic button can be located and clicked using starts-with().
driver.findElement(By.xpath("//button[starts-with(@id,'submit_')]")).click();For dynamic input fields:
driver.findElement(By.xpath("//input[starts-with(@id,'username_')]")).sendKeys("admin");starts-with() can locate an element and Selenium can then retrieve its text.
String text = driver.findElement(By.xpath("//div[starts-with(normalize-space(.),'Welcome')]")).getText();
System.out.println(text);
You can retrieve an attribute after locating the element.
WebElement element = driver.findElement(By.xpath("//input[starts-with(@id,'user_')]"));
String id = element.getAttribute("id");
System.out.println(id);
When multiple elements match the same prefix, use findElements().
List<WebElement> elements = driver.findElements(By.xpath("//input[starts-with(@id,'user_')]"));
System.out.println(elements.size());
Dynamic elements may not be immediately available. Explicit waits can be combined with starts-with() XPath.
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement loginButton = wait.until(ExpectedConditions.elementToBeClickable(By.xpath("//button[starts-with(@id,'login_')]")));
loginButton.click();
In the Page Object Model, dynamic XPath expressions can be stored in page classes.
By usernameField = By.xpath("//input[starts-with(@id,'username_')]");
By loginButton = By.xpath("//button[starts-with(@id,'login_')]");
public void login(String username) {
driver.findElement(usernameField).sendKeys(username);
driver.findElement(loginButton).click();
}
Dynamic applications may generate changing IDs, classes, URLs, or other attributes. If a stable prefix exists, starts-with() can help create a locator that does not depend on the changing suffix.
Example:
profile_1001
profile_1002
profile_1003
XPath:
//div[starts-with(@id,'profile_')]| Dynamic ID | Common Prefix | XPath |
|---|---|---|
| user_101 | user_ | //input[starts-with(@id,'user_')] |
| user_202 | user_ | //input[starts-with(@id,'user_')] |
| login_501 | login_ | //button[starts-with(@id,'login_')] |
| order_789 | order_ | //div[starts-with(@id,'order_')] |
Exact matching checks the complete attribute value.
//input[@id='username_12345']starts-with() checks only the beginning.
//input[starts-with(@id,'username_')]| Method | Purpose |
|---|---|
| @id='value' | Matches the complete attribute value. |
| starts-with(@id,'value') | Matches an attribute beginning with the specified value. |
starts-with() checks the beginning of a string, while contains() checks whether the specified value occurs anywhere in the string.
//input[starts-with(@id,'user_')]//input[contains(@id,'user_')]| Function | Matching Behavior |
|---|---|
| starts-with() | Value must occur at the beginning. |
| contains() | Value can occur anywhere. |
The text() function can be used for exact text matching.
//button[text()='Login']starts-with() can be used when the beginning is known but the remaining text changes.
//button[starts-with(normalize-space(.),'Login')]For example, this can match text such as Login Now, Login to Continue, or Login as Admin.
Selenium provides By.partialLinkText() for partial matching of link text. XPath starts-with() can provide more flexible conditions involving text and attributes.
driver.findElement(By.partialLinkText("Product")).click();XPath alternative:
driver.findElement(By.xpath("//a[starts-with(normalize-space(.),'Product')]")).click();CSS selectors also support prefix matching with ^=.
input[id^='user_']Equivalent XPath:
//input[starts-with(@id,'user_')]| XPath | CSS |
|---|---|
| starts-with(@id,'user_') | [id^='user_'] |
Multiple starts-with() conditions can be combined.
//input[starts-with(@id,'user_') and starts-with(@name,'username_')]This is useful when both attributes follow predictable naming patterns.
Sometimes different versions of an application may generate different prefixes.
//input[starts-with(@id,'user_') or starts-with(@id,'usr_')]This XPath supports both patterns.
XPath string comparisons are case-sensitive. For example:
//button[starts-with(normalize-space(.),'Login')]This does not automatically match text beginning with login or LOGIN.
For case-insensitive matching, XPath can use translate().
//button[starts-with(translate(normalize-space(.),'ABCDEFGHIJKLMNOPQRSTUVWXYZ','abcdefghijklmnopqrstuvwxyz'),'login')]Case-insensitive matching can also be applied to attributes.
//input[starts-with(translate(@id,'ABCDEFGHIJKLMNOPQRSTUVWXYZ','abcdefghijklmnopqrstuvwxyz'),'user_')]This converts uppercase letters to lowercase before performing the comparison.
A robust text-based expression can combine starts-with() and normalize-space().
//div[starts-with(normalize-space(.),'Order')]This is helpful when the page contains extra whitespace around the displayed text.
Consider:
<button>
<span>Continue</span>
</button>
A practical XPath is:
//button[starts-with(normalize-space(.),'Continue')]The dot represents the string value of the button and can include descendant text.
Suppose:
<label>Username Address</label>XPath:
//label[starts-with(normalize-space(.),'Username')]This matches the label because its text begins with Username.
Example:
//form[starts-with(@id,'registration_')]//inputThis identifies input elements inside a form whose ID begins with registration_.
A login page may contain dynamic identifiers.
//input[starts-with(@id,'username_')]
//input[starts-with(@id,'password_')]
//button[starts-with(@id,'login_')]
Selenium example:
driver.findElement(By.xpath("//input[starts-with(@id,'username_')]")).sendKeys("admin");
driver.findElement(By.xpath("//input[starts-with(@id,'password_')]")).sendKeys("admin123");
driver.findElement(By.xpath("//button[starts-with(@id,'login_')]")).click();
Dynamic registration fields can be located using stable prefixes.
driver.findElement(By.xpath("//input[starts-with(@id,'firstName_')]")).sendKeys("John");
driver.findElement(By.xpath("//input[starts-with(@id,'lastName_')]")).sendKeys("Smith");
driver.findElement(By.xpath("//input[starts-with(@id,'email_')]")).sendKeys("[email protected]");
A search result can be located using text that starts with a known word.
WebElement result = driver.findElement(By.xpath("//div[starts-with(normalize-space(.),'Selenium')]"));
System.out.println(result.getText());
Example product elements:
<div id="product_101">Laptop</div>
<div id="product_102">Mobile</div>
XPath:
//div[starts-with(@id,'product_')]Dynamic order IDs can be handled using a stable prefix.
//div[starts-with(@id,'order_')]For example:
order_1001
order_1002
order_1003
Multiple conditions can improve locator precision.
//button[starts-with(@id,'submit_') and starts-with(normalize-space(.),'Submit')]This requires both the ID and visible text to start with the specified values.
//button[starts-with(@class,'btn') and starts-with(normalize-space(.),'Login')]This combines a class prefix with a text prefix.
A broad XPath such as:
//*[starts-with(@id,'user')]may match many elements.
A more specific expression is:
//input[starts-with(@id,'user_')]Using a specific element type and stable prefix generally makes the locator easier to understand and maintain.
Before using a starts-with() XPath in a test, verify how many elements it matches.
List<WebElement> elements = driver.findElements(By.xpath("//input[starts-with(@id,'user_')]"));
System.out.println("Matches: " + elements.size());
If several elements are returned unexpectedly, refine the XPath.
XPath expressions can be tested in Chrome DevTools using the $x() function.
$x("//input[starts-with(@id,'user_')]")If the XPath is correct, Chrome returns the matching DOM elements.
$x("//button[starts-with(normalize-space(.),'Login')]")This allows you to verify whether the expected button is returned before adding the XPath to Selenium code.
Suppose a table contains dynamically generated row IDs:
<tr id="row_1001">...</tr>
<tr id="row_1002">...</tr>
XPath:
//tr[starts-with(@id,'row_')]starts-with() can be combined with text conditions.
//tr[starts-with(@id,'row_') and td[starts-with(normalize-space(.),'John')]]This selects a row whose ID starts with row_ and contains a table cell beginning with John.
An index can be applied when multiple elements match.
(//input[starts-with(@id,'user_')])[1]This selects the first matching input.
Indexing should be used carefully because the order of elements can change.
(//input[starts-with(@id,'user_')])[last()]This selects the last matching input element.
(//button[starts-with(@id,'submit_')])[2]This selects the second matching button.
public class LoginPage {
private WebDriver driver;
private By username = By.xpath("//input[starts-with(@id,'username_')]");
private By password = By.xpath("//input[starts-with(@id,'password_')]");
private By loginButton = By.xpath("//button[starts-with(@id,'login_')]");
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();
}
}
private By loginButton = By.xpath("//button[starts-with(@id,'login_')]");
public void clickLogin() {
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement button = wait.until(ExpectedConditions.elementToBeClickable(loginButton));
button.click();
}
Suppose the ID changes from:
username_12345to:
username_67890This XPath is fragile:
//input[@id='username_12345']A prefix-based XPath is more appropriate when the prefix is stable:
//input[starts-with(@id,'username_')]If the actual value is:
user_123This will not match:
//input[starts-with(@id,'username_')]The correct prefix is:
//input[starts-with(@id,'user_')]XPath matching is case-sensitive.
For:
<button>Login Now</button>This matches:
//button[starts-with(normalize-space(.),'Login')]But this does not match the same text:
//button[starts-with(normalize-space(.),'login')]If the attribute value is stable and unique, exact matching can be clearer.
//input[@id='username']There is no need to use:
//input[starts-with(@id,'user')]unless partial matching is actually required.
This expression may match several elements:
//*[starts-with(normalize-space(.),'Login')]A more specific locator is:
//button[starts-with(normalize-space(.),'Login')]starts-with() may return multiple elements when the same prefix is used repeatedly.
List<WebElement> matches = driver.findElements(By.xpath("//input[starts-with(@id,'user_')]"));
System.out.println(matches.size());
Always verify uniqueness before relying on a locator.
This expression depends on element position:
(//button[starts-with(@id,'login_')])[1]If the page structure changes, the first matching button may change. Prefer a more specific relationship or stable attribute whenever possible.
Consider the following HTML:
<div class="login-container">
<input id="user_12345" type="text" placeholder="Enter username">
<input id="pass_98765" type="password" placeholder="Enter password">
<button id="login_56789">Login to Account</button>
</div>
Create XPath expressions using starts-with().
Username:
//input[starts-with(@id,'user_')]Password:
//input[starts-with(@id,'pass_')]Login button:
//button[starts-with(@id,'login_')]Login button using text:
//button[starts-with(normalize-space(.),'Login')]WebDriver driver = new ChromeDriver();
driver.get("https://example.com");
WebElement username = driver.findElement(By.xpath("//input[starts-with(@id,'user_')]"));
username.sendKeys("admin");
WebElement password = driver.findElement(By.xpath("//input[starts-with(@id,'pass_')]"));
password.sendKeys("admin123");
WebElement login = driver.findElement(By.xpath("//button[starts-with(@id,'login_')]"));
login.click();
Suppose an e-commerce application generates product IDs like:
product_1001
product_1002
product_1003
XPath:
//div[starts-with(@id,'product_')]If the product name also begins with a known value, additional conditions can be used:
//div[starts-with(@id,'product_') and starts-with(normalize-space(.),'Laptop')]Suppose order containers use IDs such as:
order_10001
order_10002
order_10003
XPath:
//div[starts-with(@id,'order_')]Specific order text can be combined with the dynamic prefix.
//div[starts-with(@id,'order_') and starts-with(normalize-space(.),'Order')]| Requirement | XPath |
|---|---|
| Dynamic ID | //input[starts-with(@id,'user_')] |
| Dynamic Name | //input[starts-with(@name,'user_')] |
| Dynamic Class | //button[starts-with(@class,'btn-')] |
| Dynamic Href | //a[starts-with(@href,'/products/')] |
| Text Prefix | //button[starts-with(normalize-space(.),'Login')] |
| Placeholder Prefix | //input[starts-with(@placeholder,'Enter')] |
| ARIA Label Prefix | //button[starts-with(@aria-label,'Search')] |
| Data Attribute Prefix | //button[starts-with(@data-testid,'login-')] |
| Multiple Conditions | //input[starts-with(@id,'user_') and @type='text'] |
//input[starts-with(@id,'user_')]
//button[starts-with(@id,'login_')]
//a[starts-with(@href,'/products/')]
//input[starts-with(@name,'email_')]
//button[starts-with(normalize-space(.),'Login')]
//div[starts-with(normalize-space(.),'Order')]
//input[starts-with(@placeholder,'Enter')]
//button[starts-with(@aria-label,'Search')]
//tr[starts-with(@id,'row_')]
//option[starts-with(normalize-space(.),'India')]
starts-with() is an XPath string function used to check whether a string begins with a specified value. In Selenium, it is commonly used to locate elements with dynamic attributes or text.
starts-with(string, substring)//input[starts-with(@id,'user_')]Yes. For example:
//button[starts-with(normalize-space(.),'Login')]starts-with() checks the beginning of a string, whereas contains() checks whether a value occurs anywhere in the string.
Yes. XPath string matching is case-sensitive unless functions such as translate() are used to normalize the case.
Yes.
//input[starts-with(@id,'user_') and @type='text']Yes. It can be applied to attributes such as name, class, href, placeholder, aria-label, data-testid, and other attributes.
Yes. A common text-based expression is:
//button[starts-with(normalize-space(.),'Login')]Use the browser console:
$x("//input[starts-with(@id,'user_')]")Question: A username field has IDs such as username_123, username_456, and username_789. How would you locate it?
Answer:
//input[starts-with(@id,'username_')]If multiple elements match, add another stable condition such as the element type, placeholder, form relationship, or another reliable attribute.
To continue learning Selenium WebDriver, locators, WebElements, TestNG, Page Object Model, automation frameworks, and real-world automation projects, explore the JustAcademy Selenium Training Course.
You can also explore the Selenium Training Demo Registration for the course.
The starts-with() XPath function is an important technique for Selenium automation when web elements contain dynamic values but have a predictable beginning. It is particularly useful for dynamic IDs, names, URLs, placeholders, accessibility attributes, data attributes, and text patterns.
A strong Selenium automation tester should understand when to use starts-with(), when to use contains(), when exact attribute matching is better, and how to combine XPath functions with relationships and other conditions. With proper validation and stable locator design, starts-with() can be a useful part of maintainable Selenium automation scripts.
For structured Selenium learning covering WebDriver, locators, TestNG, POM, automation frameworks, cross-browser testing, and real-time projects, visit Selenium Training or register for the Selenium Course Demo.
