Selenium sendKeys(): A Complete Guide

How to Use Selenium sendKeys() in Java?

In this section, you will learn how to use Selenium sendKeys() in Java to interact with WebElements.

Test Scenario:

• Open the TestMu AI website.
• Locate the WebElement to enter the email address.
• Enter your email address.
• Click on the SIGN UP button.

Let us now see what the code for the above use case would look like, and then we will understand the code line-by-line.

package sendkeys;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test; 
public class SendkeysTest {
WebDriver driver;   
    //Method to set up the browser and open the dummy website
    @BeforeClass
    public void setUp() {           
            System.setProperty("webdriver.chrome.driver", "D:\Selenium\drivers\chromedriver.exe");
            driver = new ChromeDriver();
            driver.get("https://www.lambdatest.com");
            driver.manage().window().maximize();
    } 
    @Test
    public void testSendkeys() {
            //Locate the email and use sendkeys to pass the email to the field
            driver.findElement(By.id("email")).sendKeys("Business Email*");         
            //Locate the Start Free Testing button and click it
            driver.findElement(By.xpath("//*[@id="app"]/div/div[1]/div/div[2]/div/div[2]/div[2]/form/div[3]/button")).click();
    }      
    @AfterClass
    public void burnDown() {
            driver.quit();
    }  
}

Code Walkthrough:

• @BeforeClass annotation: The method setUp() contains the generic code to instantiate the ChromeDriver and navigate to the TestMu AI website. The page is then maximized.
• @AfterClass annotation: Similar to the setUp() method, the burnDown() method closes the browser instance.
• @Test annotation: This is the method consisting of our test case. We simply locate the text field where we have to enter the email ID and then pass on the string (our email ID) to the sendKeys() method. Next, we locate the SIGN UP button and click it.

Note: The code to use the Selenium sendKeys() method can also be written as shown below:

WebElement emailField = driver.findElement(by.id("email"));
emailField.sendKeys("Business Email*");

On running the above test, you will see that the browser actions are performed, and your email is entered into the email ID text field.

Entering Text Without Selenium sendKeys()

Although Selenium sendKeys() works almost every time, there might be a case where the text input box is disabled, and you need to pass some text to the field. In such scenarios, you need to use a sendKeys() alternative to enter text in Selenium.

Before we move on to the use case, remember that this is not the recommended way to test as the UI blocks you from entering any text in a field. Just for the sake of understanding our use case, let us consider such a scenario.

Now, you might wonder, if not the Selenium sendKeys() method, then what? One of the most effective ways to send input to text fields is to use the JavaScriptExecutor.

Let’s see what the code would look like:

JavascriptExecutor jse = ((JavascriptExecutor)driver);          
WebElement email = driver.findElement(By.id("email"));
jse.executeScript("arguments[0].value='Business Email*';", email);

As seen from the above code, we are merely passing the text box’s arguments as a script for the JavaScriptExecutor and not using the Selenium sendKeys() method.

Try using these code lines in our example above by replacing the sendKeys() code and seeing that you will get the same results as with the sendKeys() method.

Erasing Text Using Selenium sendKeys()

Next, let us consider a scenario where we need to verify that we can clear or delete the string entered in the text field. To achieve this case, we will use the Selenium clear() method, which simply erases whatever text is entered in the text field.

Consider the below test script for the same:

package sendkeys;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
public class SendkeysTest { 
WebDriver driver;


    //Method to set up the browser and open the dummy website
    @BeforeClass
    public void setUp() {


            System.setProperty("webdriver.chrome.driver", "D:\Selenium\drivers\chromedriver.exe");
            driver = new ChromeDriver();
            driver.get("https://www.lambdatest.com");
            driver.manage().window().maximize();
    }
    @Test
    public void testSendkeys() {
            //Locate the email and use sendkeys to pass the email to the field
            WebElement email = driver.findElement(By.id("email"));
            email.sendKeys("Business Email*");


            // Erase the text entered in the email id field
            email.clear();
    }  
    @AfterClass
    public void burnDown() {
            driver.quit();
    }
}

The code is the same as we explained earlier, but the only addition is the clear() method used for the email WebElement. This clear() method would erase the text entered in the text field, and you can further enter the text using the sendKeys() method as per your requirement.

Now that you understand how to use the Selenium sendKeys() method, let’s see how the TestMu AI Selenium Grid cloud can efficiently execute your tests across different system configurations.

TestMu AI is an AI-powered test orchestration and execution platform that enables devs and testers to perform test automation using Selenium Java and Selenium JavaScript at scale on a remote test lab of 3000+ real desktop browsers and operating systems.

Subscribe to the TestMu AI YouTube Channel for quick updates on the tutorials around automation testing, WebdriverIO, and more.

Implementing Selenium sendKeys() on Cloud Grid

TestMu AI provides an easy solution for executing your tests across multiple combinations by leveraging capabilities. These capabilities can be generated directly from the TestMu AI Automation Capabilities Generator and integrated into your Selenium tests.

Note that we will use the example above for execution on the TestMu AI cloud for one browser. Still, as explained in our blog on parallel testing, you can use the same test to perform cross browser testing by changing the capabilities and using @DataProvider.

package sendkeys;
import java.awt.AWTException;
import java.net.MalformedURLException;
import java.net.URL;
import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test; 

public class SendkeysTest {

            public String username = "--- your user name ---";
            public String accesskey = "--- your access key ---";
            public static RemoteWebDriver driver = null;
            public String gridURL = "@hub.lambdatest.com/wd/hub";
            boolean status = false;
    //Method to set up the browser and open the dummy website


  @BeforeClass
    public void setUp() {


            DesiredCapabilities capabilities = new DesiredCapabilities();
            capabilities.setCapability("browserName", "chrome");
            capabilities.setCapability("version", "120.0");
            capabilities.setCapability("platform", "win10"); // If this cap isn't specified, it will get any available one
            capabilities.setCapability("build", "LambdaTestProject");
            capabilities.setCapability("name", "LambdaTestSendKeysProject");
            capabilities.setCapability("network", true); // Enables network logs
            capabilities.setCapability("visual", true); // Enables step by step screenshot
            capabilities.setCapability("video", true); // Enables video recording
            capabilities.setCapability("console", true); // Captures console logs

            try {
           driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + gridURL), capabilities);
            } catch (MalformedURLException e) {
           System.out.println("Invalid grid URL");
            } catch (Exception e) {
           System.out.println(e.getMessage());
            }
            driver.get("https://www.lambdatest.com");
    } 

    @Test
    public void testSendkeys() throws AWTException {        
            //Locate the email and use sendkeys to pass the email to the field


            WebElement email = driver.findElement(By.id("useremail"));
            email.sendKeys("[email protected]");         
            //Locate the Start Free Testing button and click it
            driver.findElement(By.xpath("//*[@id='testing_form']//button")).click();




    } 

    @AfterClass
    public void burnDown() {
            driver.quit();
    } 
}

You can find these results under the TestMu AI Web Automation Dashboard.

How to Use Selenium sendKeys() in JavaScript?

In this section, you will learn how to use Selenium sendKeys() in JavaScript to interact with WebElements in Google Chrome.

Here are the steps for using the sendKeys() method in Selenium JavaScript:

Step 1: Create a New Project

• Open a terminal or command prompt.
• Create a new folder for your project using the below command:

mkdir sendkeys-selenium-tutorial

• Navigate into the project folder using the below command:

cd sendkeys-selenium-tutorial

• Initialize a new Node.js project by running the below command:

npm init -y

Step 2: Set Up VS Code

• Open VS Code.
• Navigate to your project folder by selecting File > Open Folder.
• Create a new file named test.js inside your project folder.

const { setupDriver } = require("./web-driver");

async function performSearch() {
  const driver = await setupDriver();

  try {
    // Navigate to Google's homepage
    await driver.get("<https://www.google.com/>");

    // Find the search input element and send the search query
    const searchInput = await driver.findElement(By.name("q"));
    await searchInput.sendKeys("Selenium JavaScript");

    // Submit the search using the Enter key
    await searchInput.sendKeys(Key.ENTER);

    // Wait for the search results page to load
    await driver.wait(until.titleContains("Selenium JavaScript"), 5000);

    // Print the page title
    const pageTitle = await driver.getTitle();
    console.log("Page title:", pageTitle);
  } catch (error) {
    console.error("Error occurred:", error);
  } finally {
    // Quit the driver after the test is finished
    await driver.quit();
  }
}

// Call the function to run the test
performSearch();

Step 3: Import Required Dependencies

Import the required modules for Selenium WebDriver in the test.js file.

const { Builder, By, Key, until } = require('selenium-webdriver'); 


const chrome = require('selenium-webdriver/chrome');

Step 4: Set Up Chrome WebDriver

Create a function to set up the Chrome WebDriver instance:

async function setupDriver() { 

  const options = new chrome.Options();

 // Add any necessary Chrome options here (if needed). 
 const driver = await new Builder().forBrowser('chrome') 
   .setChromeOptions(options) 
   .build(); 
  return driver; 
}

Step 5: Set Up the WebDriver Instance

Call the setupDriver() function to create a WebDriver instance (driver) and set up the Chrome WebDriver. This allows us to interact with the Chrome browser programmatically. Lastly, note that you can use other browsers with their respective drivers.

Step 6: Navigate to Google Homepage

Use the driver.get(‘https://www.google.com’) to navigate to Google’s homepage.

await driver.get('<https://www.google.com/>');

Step 7: Find the Search Input Element and Send the Search Query

Locate the search input element on the page using driver.findElement(By.name(‘q’)). Then, use the sendKeys() method to send the text Selenium JavaScript to the search input to simulate typing.

const searchInput = await driver.findElement(By.name('q'));
await searchInput.sendKeys('Selenium JavaScript');

Step 8: Submit the Search Using the Enter Key

Use sendKeys(Key.ENTER) to send the Enter key after entering the search query. This submits the search and triggers the search results.

Below is a table showing some key combinations most commonly used with the sendKeys() method:

This table may give you an insight into where we get the ENTER key combination used in the test script:

await searchInput.sendKeys(Key.ENTER);

Step 9: Wait for the Search Results Page to Load

Use the driver.wait() method to wait until the page title contains the text Selenium JavaScript. This ensures that the search results page has loaded before proceeding. In cases where the title changes or does not load. The test script will throw the Selenium exception and notify you of the error.

await driver.wait(until.titleContains('Selenium JavaScript'), 5000);

Step 10: Print the Page Title

Get the title using the driver.getTitle() method and store it in the variable pageTitle. Then, you print the title to the console using the console.log() function.

const pageTitle = await driver.getTitle();
console.log('Page title:', pageTitle);

Step 11: Handle Any Errors That Occur During the Execution

If errors occur during the execution of the try block (e.g., an element not found or page navigation issues), they will be caught in the catch block. The error message is logged to the console using the console.error() function.

} catch (error) {
    // Step 7: Handle any errors that occur during the execution
    console.error('Error occurred:', error);
  }

Step 12: Quit the Driver After the Test Is Finished

Use the driver.quit() in the finally block to close the browser and clean up the WebDriver resources after the test is finished. This ensures the browser is closed properly, even if an error occurs during the test.

finally {
    // Step 8: Quit the driver after the test is finished (cleanup)
    await driver.quit();
  }

Step 13: Call the Function to Run the Test

Call the performSearch() function to start the test and execute the steps defined in the function.

performSearch();

Step 14: Test Execution

• Open a terminal in VS Code by heading to View > Terminal.
• Run the test using Node.js by running the below command:

  node test.js

It’s important to note that there are some cases where the input field of the website you’re trying to fill might be disabled when you try to input data into it. In that case, the sendKeys() method may not work. Therefore, you need an alternative if the sendKeys() function is not working.

Let’s understand this use case where we enter text in a textbox without using the sendkeys() method.

Entering Text Without Selenium sendKeys()

JavaScriptExecutor can be a perfect alternative to input data into a field without using the sendKeys() method. However, it is generally not recommended, as the UI blocks you from entering any text in a field.

Let’s take an example using Selenium JavaScriptExecutor to input an email address into a disabled email field.

Below is a code snippet showing how to do it:

JavascriptExecutor jsExec = ((JavascriptExecutor)driver);     	
WebElement emailField = driver.findElement(By.id("input-email"));
jsExec.executeScript("arguments[0].value='---your email id---';", emailField);

In the above code snippet, we use the arguments of a text box as a script for the JavaScriptExecutor instead of using the sendKeys() method.

Let’s go through some examples of using sendKeys() to understand how this powerful method can be used for web automation.

Each example will demonstrate a specific use case, showcasing how to interact with different WebElements using sendKeys(). We will run our tests on a cloud-based grid like TestMu AI.

To get started, generate capabilities based on the configuration of your automated testing suites using the TestMu AI Automation Capability Generator and integrate them into your Selenium tests.

Here’s the test script that runs our tests on a cloud grid:

const { Builder } = require("selenium-webdriver");

const LT_USERNAME = ""; //replace with your username
const LT_ACCESS_KEY = ""; //replace with your accesskey
const GRID_HOST = "hub.lambdatest.com/wd/hub";

const capabilities = {
  browserName: "Chrome",
  browserVersion: "120.0",
  "LT:Options": {
    username: LT_USERNAME,
    accessKey: LT_ACCESS_KEY,
    geoLocation: "US",
    platformName: "Windows 10",
    build: "Examples of SendKeys",
    project: "Examples with SendKeys",
    w3c: true,
    plugin: "node_js-node_js",
  },
};

const gridUrl =
  "https://" + LT_USERNAME + ":" + LT_ACCESS_KEY + "@" + GRID_HOST;

export async function setupDriver() {
  let driver = null;
  try {
    driver = await new Builder()
      .usingServer(gridUrl)
      .withCapabilities(capabilities)
      .build();
    return driver;
  } catch (error) {
    throw error;
  } finally {
    await driver.quit();
  }
}

Once you run the tests, head over to the TestMu AI Web Automation Dashboard to view your test results.

Use Case I: Entering Text

This example demonstrates locating a text field on a web page and using the sendKeys() method to enter text.

In this case, the text [email protected] is entered into the text field with the ID input-email The submit() method is optionally used to submit the form after the text entry.

const { Builder, By } = require('selenium-webdriver');
const { setupDriver } = require("./web-driver");

async function exampleTextEntry() {
  const driver = await setupDriver();

  try {
    await driver.get('https://ecommerce-playground.lambdatest.io/index.php?route=account/login');

    // Locate the text field
    const textField = await driver.findElement(By.id('input-email'));

    // Entering text into the text field using sendKeys()
    await textField.sendKeys('[email protected]');

    // Optionally, submitting the form after text entry
    await textField.submit();

    // Wait for a few seconds (optional) to observe the results
    await driver.sleep(2000);

  } finally {
    await driver.quit();
  }
}

exampleTextEntry();

Use Case II: Entering Special Characters

In this example, the code locates a search box on the web page and uses the sendKeys() method to enter the text TestMu AI. After that, the Key.ENTER from the selenium-webdriver package is used to simulate pressing the Enter key, triggering a search action.

const { Builder, By, Key } = require('selenium-webdriver');
const { setupDriver } = require("./web-driver");

async function exampleSpecialCharacters() {
  const driver = await setupDriver();

  try {
    await driver.get('https://ecommerce-playground.lambdatest.io');

    // Locate the search box
    const searchBox = await driver.findElement(By.id('search-box'));

    // Entering 'Selenium' and then pressing the Enter key using sendKeys()
    await searchBox.sendKeys('LambdaTest', Key.ENTER);

    // Wait for a few seconds (optional) to observe the results
    await driver.sleep(2000);

  } finally {
    await driver.quit();
  }
}

exampleSpecialCharacters();

Here is the code snippet that imports the selenium-webdriver package.

const { Builder, By, Key } = require('selenium-webdriver');

It contains a Key – an object containing all the key codes, including ENTER, BACK_SPACE, etc.

Use Case III: Clearing Text

This example demonstrates using the sendKeys() method to enter text TestMu AI into a text field. After entering the text, the clear() method is used to clear the contents of the text field. The two-second sleep between actions is optional and added to observe the results.

const { Builder, By } = require('selenium-webdriver');
const { setupDriver } = require("./web-driver");

async function exampleClearField() {
  const driver = await setupDriver();

  try {
    await driver.get('https://ecommerce-playground.lambdatest.io/index.php?route=account/login');

    // Locate the text field
    const textField = await driver.findElement(By.id('input-email'));

    // Entering text into the text field using sendKeys()
    await textField.sendKeys('[email protected]');

    // Wait for a few seconds (optional) to observe the entered text
    await driver.sleep(2000);

    // Clearing the text field using the clear() method
    await textField.clear();

    // Wait for a few seconds (optional) to observe the cleared text field
    await driver.sleep(2000);

  } finally {
    await driver.quit();
  }
}

exampleClearField();

Conclusion

In this blog on Selenium sendKeys(), we discussed using the sendKeys() method in Java and JavaScript to handle different test scenarios, like entering the text in the field. We also looked at some advanced use cases of the sendKeys() method and leveraging the TestMu AI platform to run Selenium tests.

Moreover, to enhance your skills and validate your knowledge of Selenium with Java and JavaScript, you can consider taking the TestMu AI Selenium Java 101 and Selenium JavaScript 101 certifications, which gives you hands-on experience with real-life use cases of Selenium automation using Java and JavaScript.

In a nutshell, the sendKeys() method in Selenium can be helpful for developers and testers when automating data entry in automated tests. It allows you to simulate input without manually entering data in a form, reducing the time and effort spent on repetitive tasks.