The ID Locator is one of the most commonly used and generally one of the simplest locator strategies in Selenium WebDriver. It is used to identify a web element through the value of its HTML id attribute.
When a web page contains an element with a unique id, Selenium can locate that element directly using By.id(). For example, if an input field contains id="username", Selenium can locate it using driver.findElement(By.id("username")).
ID locators are especially useful for automating login forms, registration forms, search boxes, buttons, checkboxes, radio buttons, and other interactive elements. Selenium training commonly covers locators such as ID, XPath, and CSS selectors as part of WebDriver element automation. :contentReference[oaicite:0]{index=0}
Learn more through the JustAcademy's Selenium Training Course and explore the available Selenium Course Demo Registration.
A locator is a mechanism used by Selenium WebDriver to identify a particular element on a web page. Before Selenium can perform an action such as clicking, typing, selecting, or reading text, it must first locate the required WebElement.
Common Selenium locator strategies include:
The ID locator identifies an element using its HTML id attribute.
An ID Locator is a Selenium locator strategy that identifies an HTML element using its id attribute.
The basic Selenium syntax is:
driver.findElement(By.id("elementId"));For example, consider the following HTML:
<input type="text" id="username" name="user" placeholder="Enter username">The element can be located using:
driver.findElement(By.id("username"));Here, username is the value of the HTML id attribute.
The Java Selenium syntax for an ID locator is:
By.id("idValue")It is normally passed to the findElement() method:
WebElement element = driver.findElement(By.id("idValue"));For example:
WebElement username = driver.findElement(By.id("username"));The id attribute uniquely identifies an element within an HTML document. A typical HTML element may look like this:
<input id="email" type="email">In this example:
input is the HTML tag.id is the attribute.email is the attribute value.Selenium uses the value email to locate the element.
Suppose a login page contains:
<input type="text" id="username">
<input type="password" id="password">
<button id="loginButton">Login</button>
Selenium code:
driver.findElement(By.id("username")).sendKeys("admin");
driver.findElement(By.id("password")).sendKeys("admin123");
driver.findElement(By.id("loginButton")).click();
This example demonstrates three different ID locators.
ID is often a convenient locator because it directly targets the element's id attribute.
Important advantages include:
By.id() strategy.The sendKeys() method is used to enter text into an input field.
driver.findElement(By.id("username")).sendKeys("John");Example HTML:
<input type="text" id="username">The Selenium script locates the element using its ID and enters the specified text.
The click() method can be used after locating a button, checkbox, link, radio button, or another clickable element.
driver.findElement(By.id("loginButton")).click();HTML:
<button id="loginButton">Login</button>The clear() method removes existing text from an input field.
driver.findElement(By.id("username")).clear();It is useful when an input field already contains a value and the automation script needs to replace it.
The getText() method retrieves visible text from an element.
String message = driver.findElement(By.id("successMessage")).getText();
System.out.println(message);
HTML:
<div id="successMessage">Login successful</div>The getAttribute() method can retrieve an attribute value from an element.
String value = driver.findElement(By.id("username")).getAttribute("value");
System.out.println(value);
This is useful when the value entered into an input field needs to be validated.
<input type="text" id="firstName">Selenium:
driver.findElement(By.id("firstName")).sendKeys("Rahul");<input type="password" id="password">Selenium:
driver.findElement(By.id("password")).sendKeys("Pass@123");<button id="submitButton">Submit</button>Selenium:
driver.findElement(By.id("submitButton")).click();<input type="checkbox" id="terms">Selenium:
WebElement terms = driver.findElement(By.id("terms"));
if (!terms.isSelected()) {
terms.click();
}
<input type="radio" id="male" name="gender" value="male">Selenium:
driver.findElement(By.id("male")).click();<input type="search" id="searchBox">Selenium:
driver.findElement(By.id("searchBox")).sendKeys("Selenium WebDriver");<a id="homeLink" href="/home">Home</a>Selenium:
driver.findElement(By.id("homeLink")).click();<div id="profile">
User Profile
</div>
Selenium:
String text = driver.findElement(By.id("profile")).getText();
System.out.println(text);
Instead of directly performing an action, an element can be stored in a WebElement variable.
WebElement username = driver.findElement(By.id("username"));
username.sendKeys("admin");
This approach is useful when the same element needs to be used multiple times.
For a Java Selenium program, commonly required imports include:
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 IdLocatorExample {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
driver.get("https://example.com/login");
driver.findElement(By.id("username")).sendKeys("admin");
driver.findElement(By.id("password")).sendKeys("admin123");
driver.findElement(By.id("loginButton")).click();
driver.quit();
}
}
Consider the following login form:
<form>
<input type="text" id="username">
<input type="password" id="password">
<button id="login">Login</button>
</form>
Automation code:
driver.findElement(By.id("username")).sendKeys("john");
driver.findElement(By.id("password")).sendKeys("john123");
driver.findElement(By.id("login")).click();
<input type="text" id="firstName">
<input type="text" id="lastName">
<input type="email" id="email">
<input type="password" id="password">
<button id="register">Register</button>
Selenium:
driver.findElement(By.id("firstName")).sendKeys("John");
driver.findElement(By.id("lastName")).sendKeys("Smith");
driver.findElement(By.id("email")).sendKeys("[email protected]");
driver.findElement(By.id("password")).sendKeys("Pass@123");
driver.findElement(By.id("register")).click();
<input id="search" type="text">
<button id="searchButton">Search</button>
driver.findElement(By.id("search")).sendKeys("Laptop");
driver.findElement(By.id("searchButton")).click();
A checkbox can be selected conditionally to avoid clicking it when it is already selected.
WebElement checkbox = driver.findElement(By.id("terms"));
if (!checkbox.isSelected()) {
checkbox.click();
}
WebElement maleRadio = driver.findElement(By.id("male"));
if (!maleRadio.isSelected()) {
maleRadio.click();
}
When multiple elements need to be handled, findElements() can be used.
List<WebElement> elements = driver.findElements(By.id("product"));However, an ID is normally expected to identify one unique element. If the same ID appears on multiple elements, the HTML is not following the normal uniqueness expectation for IDs, and automation can become ambiguous.
Consider:
<input id="username">
<input id="password">
Each element has a different ID. This makes the elements easy to distinguish.
Using the same ID repeatedly is poor HTML practice:
<input id="username">
<input id="username">
Automation scripts should avoid depending on duplicated IDs.
| Feature | ID Locator | Name Locator |
|---|---|---|
| Syntax | By.id("username") | By.name("username") |
| Attribute | id | name |
| Common Use | Unique elements | Form fields |
| Example | id="username" | name="username" |
| Feature | ID | Class Name |
|---|---|---|
| HTML Attribute | id | class |
| Java Syntax | By.id() | By.className() |
| Typical Purpose | Unique identification | Grouping/styling |
| Example | id="login" | class="btn" |
| Feature | ID | XPath |
|---|---|---|
| Syntax | By.id() | By.xpath() |
| Complexity | Simple | Can be simple or complex |
| Attribute Support | ID attribute | Many attributes and relationships |
| Text Matching | No direct text matching | Yes |
| Axes | No | Yes |
| Typical Use | Stable unique ID | Complex or dynamic elements |
An ID can also be represented in CSS selector syntax using #.
#usernameSelenium CSS example:
driver.findElement(By.cssSelector("#username"));For a direct ID locator, Selenium provides:
driver.findElement(By.id("username"));An ID locator is particularly suitable when the application's ID is:
<input id="emailAddress" type="email">This is a clear and readable ID.
driver.findElement(By.id("emailAddress")).sendKeys("[email protected]");Some applications generate IDs dynamically.
<input id="input_12345" type="text">On another execution, the ID might become:
<input id="input_98765" type="text">In this situation, directly using By.id() with the changing value may make the automation script unstable.
If the ID changes every time the application loads, the locator written in the automation script may no longer match the element.
For example:
driver.findElement(By.id("input_12345"));If the application generates input_67890 during the next execution, Selenium may throw NoSuchElementException.
When an ID is dynamic, inspect the HTML and identify another stable attribute or relationship.
For example:
<input id="user_12345" name="username" type="text">If the name attribute is stable, it may be used instead:
driver.findElement(By.name("username"));Alternatively, a CSS selector or XPath can be used when appropriate.
Sometimes an element has a valid ID but is not immediately available for interaction. An explicit wait can be used.
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement username = wait.until(
ExpectedConditions.visibilityOfElementLocated(By.id("username"))
);
username.sendKeys("admin");
For buttons and other interactive elements, waiting until the element is clickable can be useful.
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement login = wait.until(
ExpectedConditions.elementToBeClickable(By.id("loginButton"))
);
login.click();
import java.time.Duration;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
In the Page Object Model, locators can be stored as class fields so that page interaction logic remains organized.
public class LoginPage {
private WebDriver driver;
private By username = By.id("username");
private By password = By.id("password");
private By loginButton = By.id("loginButton");
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();
}
}
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.annotations.Test;
public class LoginTest {
@Test
public void loginTest() {
WebDriver driver = new ChromeDriver();
driver.get("https://example.com/login");
driver.findElement(By.id("username")).sendKeys("admin");
driver.findElement(By.id("password")).sendKeys("admin123");
driver.findElement(By.id("loginButton")).click();
driver.quit();
}
}
The isDisplayed() method can be used to check whether the located element is visible.
WebElement message = driver.findElement(By.id("successMessage"));
if (message.isDisplayed()) {
System.out.println("Success message is displayed.");
}
WebElement button = driver.findElement(By.id("submit"));
if (button.isEnabled()) {
System.out.println("Button is enabled.");
}
This is useful for checkboxes and radio buttons.
WebElement checkbox = driver.findElement(By.id("terms"));
if (checkbox.isSelected()) {
System.out.println("Checkbox is selected.");
}
WebElement email = driver.findElement(By.id("email"));
System.out.println(email.getAttribute("type"));
System.out.println(email.getAttribute("placeholder"));
System.out.println(email.getAttribute("value"));
Several Selenium exceptions can occur when working with ID locators.
| Exception | Possible Cause |
|---|---|
| NoSuchElementException | ID does not exist or element is not available |
| StaleElementReferenceException | DOM changed after the element was located |
| ElementNotInteractableException | Element exists but cannot currently be interacted with |
| ElementClickInterceptedException | Another element is blocking the click |
| TimeoutException | Explicit wait condition was not satisfied |
Example:
driver.findElement(By.id("wrongId")).click();If wrongId does not exist on the current page, Selenium may throw NoSuchElementException.
Check the following:
If the element is inside an iframe, Selenium must switch to that iframe before locating the inner element.
WebElement frame = driver.findElement(By.id("paymentFrame"));
driver.switchTo().frame(frame);
driver.findElement(By.id("cardNumber")).sendKeys("4111111111111111");
driver.switchTo().defaultContent();
An ID locator works within the currently active browsing context. If a new window or tab opens, Selenium must switch to the correct window before locating the element.
String originalWindow = driver.getWindowHandle();
for (String window : driver.getWindowHandles()) {
if (!window.equals(originalWindow)) {
driver.switchTo().window(window);
break;
}
}
driver.findElement(By.id("newWindowElement")).click();
Elements inside a Shadow DOM may require Shadow Root handling rather than ordinary document-level locating.
An ID visible inside a shadow tree cannot always be located simply with:
driver.findElement(By.id("shadowElement"));The correct approach depends on how the application implements the Shadow DOM and the Selenium/WebDriver APIs being used.
Modern applications frequently update the DOM using JavaScript, AJAX, React, Angular, Vue, or other frameworks. In such cases, an ID may exist only after a particular action or API response.
A wait can help synchronize the automation script with the application.
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement element = wait.until(
ExpectedConditions.presenceOfElementLocated(By.id("dynamicElement"))
);
| Condition | Purpose |
|---|---|
| presenceOfElementLocated | Checks that the element exists in the DOM |
| visibilityOfElementLocated | Checks that the element exists and is visible |
| elementToBeClickable | Checks that the element can be interacted with for clicking |
An element with ID username can also be located using CSS:
driver.findElement(By.cssSelector("#username"));The # symbol represents an ID selector in CSS.
The same element can be located using XPath:
driver.findElement(By.xpath("//*[@id='username']"));However, if a stable unique ID is directly available, By.id("username") is usually simpler.
<input id="productSearch" type="text">
<button id="searchProduct">Search</button>
driver.findElement(By.id("productSearch")).sendKeys("Laptop");
driver.findElement(By.id("searchProduct")).click();
<button id="addToCart">Add to Cart</button>
<button id="checkout">Checkout</button>
driver.findElement(By.id("addToCart")).click();
driver.findElement(By.id("checkout")).click();
<a id="home" href="/home">Home</a>
<a id="products" href="/products">Products</a>
<a id="contact" href="/contact">Contact</a>
driver.findElement(By.id("products")).click();<button type="submit" id="submitForm">Submit Form</button>driver.findElement(By.id("submitForm")).click();<span id="emailError">Invalid email address</span>String error = driver.findElement(By.id("emailError")).getText();
if (error.equals("Invalid email address")) {
System.out.println("Validation message verified.");
}
<div id="successMessage">Registration successful</div>String message = driver.findElement(By.id("successMessage")).getText();
System.out.println(message);
An element may exist in the DOM but not be visible.
<div id="hiddenMessage" style="display:none">Hidden Message</div>Selenium may locate the element:
WebElement message = driver.findElement(By.id("hiddenMessage"));But attempting an interaction such as clicking or typing may fail because the element is not visible or interactable.
<button id="submitButton" disabled>Submit</button>Selenium can locate the element, but the element may not be interactable while disabled.
WebElement submit = driver.findElement(By.id("submitButton"));
System.out.println(submit.isEnabled());
driver.findElement(By.id("userName"));If the actual ID is username, the locator will not match.
HTML attribute values are generally case-sensitive for locator matching. These are different values:
id="username"
id="UserName"
Generated IDs can change between executions and make tests unstable.
A valid ID on another page will not locate an element if the browser is currently on a different page.
An element inside an iframe requires switching into the correct frame first.
Meaningful variable names improve readability.
private By usernameField = By.id("username");
private By passwordField = By.id("password");
private By loginButton = By.id("loginButton");
This is easier to understand than:
private By element1 = By.id("username");
private By element2 = By.id("password");
private By element3 = By.id("loginButton");
public void enterText(By locator, String text) {
driver.findElement(locator).clear();
driver.findElement(locator).sendKeys(text);
}
Usage:
enterText(By.id("username"), "admin");
enterText(By.id("email"), "[email protected]");
public void click(By locator) {
driver.findElement(locator).click();
}
Usage:
click(By.id("loginButton"));
click(By.id("submitButton"));
public WebElement waitForElement(By locator) {
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
return wait.until(ExpectedConditions.visibilityOfElementLocated(locator));
}
Usage:
WebElement username = waitForElement(By.id("username"));
username.sendKeys("admin");
WebDriver driver = new ChromeDriver();
driver.get("https://example.com/login");
WebElement username = driver.findElement(By.id("username"));
WebElement password = driver.findElement(By.id("password"));
WebElement login = driver.findElement(By.id("loginButton"));
username.sendKeys("admin");
password.sendKeys("admin123");
login.click();
driver.quit();
driver.findElement(By.id("firstName")).sendKeys("John");
driver.findElement(By.id("lastName")).sendKeys("Smith");
driver.findElement(By.id("email")).sendKeys("[email protected]");
driver.findElement(By.id("password")).sendKeys("Pass@123");
driver.findElement(By.id("confirmPassword")).sendKeys("Pass@123");
driver.findElement(By.id("registerButton")).click();
WebElement search = driver.findElement(By.id("searchBox"));
search.sendKeys("Selenium WebDriver");
driver.findElement(By.id("searchButton")).click();
driver.findElement(By.id("addToCart")).click();
driver.findElement(By.id("cart")).click();
driver.findElement(By.id("checkout")).click();
id attribute.By.id() locator.Start
|
v
Inspect Web Element
|
v
Does it have an ID?
|
+---- No ----> Consider Name / Class / CSS / XPath
|
Yes
|
v
Is the ID unique?
|
+---- No ----> Find a more reliable locator
|
Yes
|
v
Is the ID stable?
|
+---- No ----> Find a stable attribute or relationship
|
Yes
|
v
Use By.id("value")
|
v
Add appropriate wait if required
|
v
Perform WebElement action
WebElement message = driver.findElement(By.id("successMessage"));
String actualMessage = message.getText();
Assert.assertEquals(actualMessage, "Registration successful");
import org.testng.Assert;
import org.testng.annotations.Test;
@Test
public void verifyMessage() {
WebElement message = driver.findElement(By.id("successMessage"));
Assert.assertTrue(message.isDisplayed());
}
The locator can remain constant while the test data changes.
String username = "admin";
String password = "admin123";
driver.findElement(By.id("username")).sendKeys(username);
driver.findElement(By.id("password")).sendKeys(password);
driver.findElement(By.id("loginButton")).click();
ID locators are frequently stored inside Page Object classes, utility classes, or locator repositories. This allows the test framework to separate element identification from test execution logic.
A typical structure can be:
src
├── pages
│ └── LoginPage.java
├── tests
│ └── LoginTest.java
├── utilities
│ └── WebDriverUtility.java
└── testdata
└── loginData.xlsx
A locator is maintainable when it continues to identify the intended element despite normal UI changes.
For example, this is generally more readable:
By.id("loginButton")than a long XPath when the element already has a stable ID.
Readable locators help automation engineers quickly understand what element a test is interacting with.
driver.findElement(By.id("email")).sendKeys("[email protected]");The purpose of the statement is immediately clear.
A stable ID can contribute to stable automation because the locator directly targets the intended element rather than relying on a long DOM hierarchy.
However, locator stability ultimately depends on the application's HTML implementation and whether the ID remains unchanged.
Answer: An ID Locator is a Selenium WebDriver locator strategy used to identify a web element using the value of its HTML id attribute. In Java Selenium, it is commonly written as driver.findElement(By.id("value")).
Answer:
driver.findElement(By.id("username"));For entering text:
driver.findElement(By.id("username")).sendKeys("admin");Answer: ID is convenient because it directly identifies an element through the HTML id attribute. When the ID is unique and stable, the locator is simple and readable.
Answer: If the ID changes dynamically, directly using the changing value may make the locator unreliable. The tester should inspect the element for another stable attribute or use an appropriate CSS selector or XPath strategy.
Answer: An ID is intended to identify an element uniquely within a document. If multiple elements use the same ID, the HTML structure does not provide the expected uniqueness, and automation based on that ID can become ambiguous.
Answer: Yes, Selenium allows findElements(By.id("value")), but an ID is normally intended to identify one unique element. If multiple matching elements are returned because of duplicate IDs, the HTML should be inspected.
Answer: ID is direct and simple when a stable ID is available. XPath supports more complex matching, text conditions, DOM relationships, and axes. The locator should be selected according to the structure and stability of the application.
Answer: An ID can be directly located using By.id(), while CSS can use an ID selector such as #username. CSS selectors also support many additional attribute and relationship patterns.
Answer: Yes, if the element has a stable ID at the time it is located. If the element appears dynamically, an appropriate wait may be required. If the ID itself changes, another stable locator strategy may be necessary.
Answer: Selenium commonly throws NoSuchElementException when it cannot find the element matching the supplied locator in the current browsing context.
Answer: Yes, but Selenium must first switch to the iframe containing the element. After switching to the correct frame, the ID locator can be used normally.
Answer: Yes. For example:
driver.findElement(By.id("submitButton")).click();Answer: Yes. For example:
WebElement checkbox = driver.findElement(By.id("terms"));
if (!checkbox.isSelected()) {
checkbox.click();
}
Answer: Yes. A radio button can be located by its ID and clicked if it is not already selected.
WebElement radio = driver.findElement(By.id("male"));
if (!radio.isSelected()) {
radio.click();
}
Build an automation script for a login page using ID locators for the username field, password field, login button, and success message.
driver.get("https://example.com/login");
driver.findElement(By.id("username")).sendKeys("admin");
driver.findElement(By.id("password")).sendKeys("admin123");
driver.findElement(By.id("loginButton")).click();
WebElement message = driver.findElement(By.id("successMessage"));
System.out.println(message.getText());
Create an automation script that fills a registration form using ID locators.
driver.findElement(By.id("firstName")).sendKeys("John");
driver.findElement(By.id("lastName")).sendKeys("Smith");
driver.findElement(By.id("email")).sendKeys("[email protected]");
driver.findElement(By.id("password")).sendKeys("Pass@123");
driver.findElement(By.id("confirmPassword")).sendKeys("Pass@123");
WebElement terms = driver.findElement(By.id("terms"));
if (!terms.isSelected()) {
terms.click();
}
driver.findElement(By.id("registerButton")).click();
driver.get("https://example.com/products");
driver.findElement(By.id("searchBox")).sendKeys("Laptop");
driver.findElement(By.id("searchButton")).click();
driver.findElement(By.id("addToCart")).click();
driver.findElement(By.id("cartButton")).click();
driver.findElement(By.id("checkoutButton")).click();
driver.findElement(By.id("email")).sendKeys("invalid-email");
driver.findElement(By.id("submitButton")).click();
WebElement error = driver.findElement(By.id("emailError"));
System.out.println(error.getText());
Open Web Page
|
v
Inspect HTML
|
v
Find id Attribute
|
v
Check ID Stability
|
v
Create By.id()
|
v
Locate WebElement
|
v
Apply Action
|
v
Validate Result
| Action | Example |
|---|---|
| Locate | driver.findElement(By.id("username")) |
| Type | driver.findElement(By.id("username")).sendKeys("admin") |
| Clear | driver.findElement(By.id("username")).clear() |
| Click | driver.findElement(By.id("login")).click() |
| Get Text | driver.findElement(By.id("message")).getText() |
| Get Attribute | driver.findElement(By.id("email")).getAttribute("value") |
| Displayed | driver.findElement(By.id("message")).isDisplayed() |
| Enabled | driver.findElement(By.id("submit")).isEnabled() |
| Selected | driver.findElement(By.id("terms")).isSelected() |
| Practice | Recommendation |
|---|---|
| Unique ID | Prefer IDs that uniquely identify one element. |
| Stable ID | Prefer IDs that do not change between executions. |
| Readable ID | Use meaningful IDs when the application provides them. |
| Dynamic ID | Look for stable alternatives when IDs are generated dynamically. |
| Waits | Use synchronization when elements appear asynchronously. |
| POM | Store locators in Page Object classes for maintainability. |
| Validation | Verify the resulting page state after interactions. |
import java.time.Duration;
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.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
public class CompleteIdLocatorExample {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
try {
driver.manage().window().maximize();
driver.get("https://example.com/login");
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement username = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("username")
)
);
WebElement password = driver.findElement(By.id("password"));
WebElement loginButton = driver.findElement(By.id("loginButton"));
username.sendKeys("admin");
password.sendKeys("admin123");
loginButton.click();
WebElement successMessage = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("successMessage")
)
);
System.out.println(successMessage.getText());
} finally {
driver.quit();
}
}
}
By.id() for a stable ID.findElement() for a single target element.findElements() when multiple matches are intentionally required.The ID Locator is an important Selenium WebDriver locator strategy used to identify elements through their HTML id attribute. Its syntax is simple: By.id("idValue").
When an element has a unique and stable ID, using an ID locator can make Selenium automation code simple, readable, and maintainable. ID locators can be used with text fields, passwords, buttons, links, checkboxes, radio buttons, messages, search fields, and many other WebElements.
For dynamic applications, testers should verify whether the ID remains stable and use appropriate waits or alternative locator strategies when necessary. Understanding ID locators provides a strong foundation for learning other Selenium locator strategies such as Name, Class Name, CSS Selector, and XPath.
For structured Selenium automation learning, explore the JustAcademy's Selenium Training Course.
To explore the course and request a demo, visit Register for Course Demo.
