Automating File Uploads in Selenium in 2026

Automating File Uploads in Selenium in 2026

Uploading files is a common feature in many web applications, whether it’s submitting documents, uploading images, or sharing content. Selenium WebDriver makes it easy to automate these actions by simulating real user interactions with the browser.

This guide explains how to handle file uploads in Selenium, explore different methods, and apply them in real-world scenarios for accurate and reliable testing.

Understanding Selenium WebDriver

Selenium WebDriver is a powerful automation framework used to test web applications across different browsers and platforms. It allows testers and developers to simulate real user interactions, such as clicking buttons, entering text, or navigating pages, just like a human would.

Unlike older Selenium versions that relied on the Selenium RC server, WebDriver communicates directly with the browser, making it faster, more efficient, and reliable. It supports multiple browsers like Chrome, Firefox, Edge, and Safari, as well as multiple programming languages including C#, Java, Python, and JavaScript.

In the context of C#, Selenium WebDriver integrates seamlessly with testing frameworks such as NUnit or MSTest, allowing developers to write structured, maintainable test cases that can be executed from Visual Studio.

Different Methods to Upload File in Selenium

Here are the different methods to upload a file in Selenium:

1. Using sendKeys() Method: The simplest and most common method to upload a file is by using the sendKeys() method on the file input element. This method simulates entering a file path into the file upload field.

2. Using AutoIt Tool: When dealing with native OS file dialog boxes, Selenium cannot directly interact with them. In such cases, the AutoIt tool (for Windows) can be used to handle the file upload dialog and send the file path.

3. Using Robot Class: For Java users, the Robot class can simulate keyboard and mouse actions to interact with file dialog boxes. It’s useful when the file input field is triggered by a native OS dialog.

4. Using JavaScript Executor: For hidden or styled file input elements, JavaScript Executor can be used to make the file input field visible, allowing Selenium to interact with it directly for file upload.

5. Using External Libraries or APIs: For applications with REST APIs for file uploads, it may be more efficient to upload the file directly using an HTTP client like RestSharp (C#) or

HttpClient instead of relying on UI automation. This method is typically faster and bypasses the UI entirely.

Each of these methods is applicable based on the specific requirements of the application you are automating, such as whether the file input is hidden, whether the upload trigger uses native OS dialogs, or whether the backend supports API-based file uploads.

Step-by-Step Guide: Uploading Files with Selenium

Uploading files is a common task in web applications, and Selenium WebDriver provides several ways to automate file uploads. Below are the steps on how to upload files using Selenium.

Step 1: Locate the File Upload Element

The first step is to locate the file input element (<input type=”file”>) on the webpage. This element is responsible for triggering the file selection dialog.

You can locate the element using different locators like By.id(), By.name(), By.xpath(), etc.

Step 2: Choose the Method for Uploading the File

There are several methods to interact with the file input and upload a file. Depending on the scenario, you will choose the appropriate method.

Step 3: Verify the File Upload

Once the file has been uploaded, it’s essential to verify that the upload was successful. This can be done by checking for the following:

• Confirmation Message: Ensure that a success message or dialog appears after the upload.
• File Visibility: Verify that the uploaded file is listed on the page or can be accessed via the file manager or the application itself.

Step 4: Clean Up

After the test, make sure to properly clean up any resources used, such as closing the browser or removing temporary files if necessary.

Real Example: Uploading a Profile Picture to GitHub

This example walks you through the process of automating the file upload of a profile picture on GitHub using Selenium WebDriver in C#. This scenario assumes you want to automate the process of logging into GitHub and uploading a profile picture via the web interface.

1. Navigate to GitHub and Log In: Open the GitHub login page, input your username and password, and submit to log in. You can find the login form using By.id() for the username and password fields.

2. Go to Profile Settings: After logging in successfully, navigate to your GitHub profile settings page where the option to upload a profile picture exists. This page URL is typically https://github.com/settings/profile.

3. Locate the File Input Element: Identify the file input field on the profile settings page. It will be an <input type=”file”> element, often hidden or styled differently. You can locate it using By.xpath() or By.cssSelector().

4. Send the Image File Path: Use the sendKeys() method to provide the absolute file path of the image you want to upload. Ensure that the path is correct and points to the image file on your local machine.

5. Save or Submit the Change: After selecting the file, find the “Save” or “Update” button on the page and click it to upload and set the new profile picture.

6. Verify Upload Success: Finally, verify that the profile picture has been successfully uploaded. You can do this by checking if the profile image is visible on the page or by looking for a success message.

Sample C# Code Snippet for Profile Picture Upload

using OpenQA.Selenium;

using OpenQA.Selenium.Chrome;

using System;

using System.Threading;



class GitHubProfilePictureUpload

{

    static void Main()

    {

        // Initialize the Chrome WebDriver

        IWebDriver driver = new ChromeDriver();



        // Step 1: Navigate to the GitHub login page

        driver.Navigate().GoToUrl("https://github.com/login");



        // Step 2: Log in by providing username and password

        driver.FindElement(By.Id("login_field")).SendKeys("your_username");

        driver.FindElement(By.Id("password")).SendKeys("your_password");

        driver.FindElement(By.Name("commit")).Click();



        // Step 3: Navigate to the profile settings page

        driver.Navigate().GoToUrl("https://github.com/settings/profile");



        // Step 4: Locate the file input element and upload the image

        IWebElement uploadButton = driver.FindElement(By.XPath("//input[@type='file']"));

        uploadButton.SendKeys(@"C:\path\to\your\profile-picture.jpg");



        // Step 5: Click the 'Save' button to update the profile picture

        driver.FindElement(By.XPath("//button[contains(text(),'Save')]")).Click();



        // Step 6: Verify the profile picture upload by checking the presence of the new image

        IWebElement profileImage = driver.FindElement(By.CssSelector(".avatar.avatar-large"));

        if (profileImage.Displayed)

        {

            Console.WriteLine("Profile picture uploaded successfully!");

        }

        else

        {

            Console.WriteLine("Profile picture upload failed.");

        }



        // Close the browser

        driver.Quit();

    }

}

Explanation of the Code:

1. Initialize WebDriver: Start by initializing the ChromeDriver to control the Chrome browser.
2. Log in: Find the login fields and input the username and password, then click the login button.
3. Navigate to Profile Settings: After successful login, navigate to the profile settings page.
4. File Upload: The file input element is located using XPath, and we use sendKeys() to provide the file path to upload the profile picture.
5. Submit the Changes: After selecting the file, the “Save” button is clicked to apply the changes.
6. Verification: Verify the upload by checking if the profile image is visible on the page.

Importance of Running Upload Tests on Real Devices

Running upload tests on real devices is crucial for ensuring the accuracy and reliability of file uploads in web applications. Here’s why:

1. Accurate File System Interaction: Real devices offer accurate handling of file paths, permissions, and storage types (e.g., local, cloud, or external storage) that simulators can’t replicate.
2. Device-Specific Storage and Permissions: Real devices handle storage differently (e.g., mobile cloud storage or external SD cards). Testing ensures your app works with various storage sources and permissions.
3. Real Network Conditions: Real-world network issues like slow speeds or interruptions can affect uploads. Testing on real devices simulates these scenarios to ensure reliable uploads.
4. UI/UX Testing: Testing on real devices confirms that file upload buttons, file pickers, and UI elements function correctly on different screen sizes and orientations.
5. Detecting Device-Specific Bugs: Real device testing uncovers issues related to browser compatibility, device restrictions, and performance, which simulators often miss.
6. Compliance with Platform Guidelines: For mobile apps, testing ensures file upload features meet Google Play and Apple App Store guidelines for accessing device storage.

Conclusion

Incorporating real device testing for file uploads is essential to ensure that your application performs as expected across different platforms, devices, and network conditions.

By testing on real devices, you can uncover device-specific bugs, handle storage permissions, and ensure smooth user experiences with file pickers and UI elements. This not only enhances the functionality of your application but also ensures compliance with platform-specific guidelines.