Author: Paulo Oliveira

Paulo is an accomplished Quality Assurance Engineer with over 17 years of extensive experience in Software Testing. His passion lies in automating tests across diverse applications, including both backend and frontend, to streamline team workflows, enhance product quality, and ensure utmost customer satisfaction. Beyond his hands-on testing responsibilities, Paulo has excelled in leadership roles as a QA Lead, where he adeptly plans, coordinates, and inspires team activities while providing invaluable coaching and guidance to foster the professional development of his colleagues. Paulo's enthusiasm for sharing knowledge and mentoring others to achieve their goals is palpable, reflecting his unwavering commitment to excellence in every aspect of his work.
Selenium Python Tutorial for Beginners

In today’s rapidly evolving software development landscape, the dependability and functionality of web applications are really important. When used in conjunction with Python, Selenium presents a sophisticated answer to many urgent issues faced in the test automation area. It effectively tackles the need for swift, consistent, and precise testing of web applications across various browsers and environments. Utilizing Selenium enables QAs to streamline the testing process by automating it, considerably cutting down the time and manual labor involved in monotonous test scenarios. This automation accelerates the development process and substantially improves the software’s quality and dependability, ensuring web applications perform reliably in diverse situations.

This article takes a deep dive into the synergy of Selenium and Python, revealing how it revolutionizes the process of test automation. We will navigate through the fundamentals of Selenium, providing practical samples and guidance on creating your first script with Selenium and Python. We’ll focus on locating basic elements on a webpage and interacting with them effectively. This hands-on approach is designed to benefit both beginners and experienced QAs, offering a clear pathway to mastering the fundamentals of Selenium and Python in web automation. You will thoroughly grasp how Selenium with Python is transforming the landscape of software testing.

Introduction to Selenium and Automated Testing

Let’s start by understanding the historical perspective of Selenium and its evolution, as well as the importance of Selenium for test automation.

Selenium: A Historical Perspective and Its Growth

Selenium, conceived by Jason Huggins in 2004, has emerged as a pivotal element in web automation technology. Originally thought as a tool for internal browser automation, it swiftly transitioned to an open-source platform, garnering widespread acceptance due to its versatility and robustness. 

Selenium’s evolution from its initial JavaScript-focused Selenium RC to the comprehensive Selenium WebDriver in the Selenium 2.0 suite marks its growth. Presently, Selenium’s support extends to multiple languages like Python, Java, C#, and Ruby, and it is compatible with various browsers and operating systems, giving it a status as a preferred web automation tool.

The significance of Selenium in web automation comes from its capability to mimic human interactions with web pages, from clicking buttons to entering data and retrieving information. It excels in automating intricate web applications and executing tasks with precision and repeatability, crucial for various testing types like regression, functional, and load testing. 

Selenium’s adaptability across different browsers and operating systems further bolsters its utility, empowering QAs to ensure consistent web application functionality across diverse platforms.

Selenium in the Automated Testing Landscape

Among a variety of web automation tools, Selenium distinguishes itself in several aspects. Contrary to proprietary tools, Selenium is an open-source, cost-free solution, making it more accessible to a broad spectrum of QAs and smaller enterprises. It surpasses other proprietary tools in language support and browser compatibility. Additionally, Selenium benefits from a vibrant community that contributes to a wealth of resources and consistent updates, keeping it in line with the latest web technology trends.

Applications and Suitability

Selenium’s utility and importance are demonstrated through its practical applications in a range of web application testing scenarios:

  • Functional Testing: Imagine checking every web application feature to ensure it works as intended. Selenium automates this process, efficiently validating each function, from user logins to data processing.
  • Regression Testing: After updates or changes, confirming they haven’t disrupted existing functionalities is crucial. Selenium automates these checks, seamlessly ensuring that new code doesn’t introduce errors into previously stable features.
  • Load Testing: Consider a scenario where a web application must perform under heavy user load. Although Selenium itself doesn’t conduct load testing, it can be integrated with tools like JMeter to test how an application behaves under stress, ensuring stability.
  • Cross-Browser Testing: Web applications must work consistently across different browsers. Selenium automates this process, testing compatibility and performance across multiple browsers, thus guaranteeing a uniform user experience.
  • Data-Driven Testing: When testing involves various data inputs, Selenium is able to run the same scenarios with different data to validate multiple outcomes effectively.

These practical examples underscore Selenium’s versatility in testing web application testing, highlighting its critical role in ensuring software quality and reliability.

Selenium’s progression from a rudimentary tool to an internationally recognized web automation framework underscores its pivotal role in test automation. Its compatibility with diverse programming languages, browsers, and operating systems, coupled with its capacity to enable efficient and accurate automated testing, positions Selenium as an essential instrument in contemporary software development. Selenium’s adaptability and scalability make it useful for a variety of test automation requirements.

Environment Configuration for Automated Testing

Embarking on automated testing with Python and Selenium requires an initial setup to create an efficient development environment. This concise guide will walk you through installing Python and Selenium WebDriver, and how to establish a test environment with an IDE such as Visual Studio Code.


Python’s ease of use and readability makes it ideal for web testing. 

To install Python:

  • Downloading Python: Navigate to and download the most recent Python version for your OS. Prefer Python 3.x for its updated features and support.
  • Installation Process: Execute the downloaded file. Remember to select “Add Python 3.x to PATH” before finalizing the installation, enabling command line access.
  • Confirming Installation: Verify Python’s installation by running the below command in the command line tool of your OS:
python –version
  • Pip Update: Update Python’s package manager, pip, by executing the below command: 
python.exe -m pip install –upgrade pip 

Selenium WebDriver

Here is how to set up Selenium WebDriver for browser automation:

In the command line, run the below command to install it:

pip install selenium 

Visual Studio Code

Selecting a powerful IDE is crucial for script development. For this article, we will use Visual Studio Code.

To integrate with Visual Studio Code (VS Code), follow these simple steps:

  • Install VS Code: Download and install Visual Studio Code from its official website
  • Add Python Extension: In VS Code, go to Extensions and install the Python extension. This extension enhances your coding experience with features like IntelliSense and debugging.

Following these streamlined steps will result in a well-integrated setup for Python and Selenium WebDriver within Visual Studio Code, ideal for creating, executing, and debugging automated web tests, thus ensuring web application functionality and stability.

Basics of Selenium with Python

The integration of Selenium with Python has become a crucial skill set for professionals in software testing and web automation. This section delves into the foundational aspects of using Selenium with Python, focusing specifically on understanding the WebDriver and creating your first Selenium script.

Understanding WebDriver

Selenium WebDriver is a fundamental component of the Selenium suite. It’s a web automation framework that allows you to execute tests against different browsers, like Chrome, Firefox, and Internet Explorer. WebDriver directly interacts with the web browser and uses its native compatibility to automate.

Unlike its predecessor, Selenium RC, which required a server to interact with the web browser, WebDriver interacts directly with the browser applications. This direct interaction is achieved through a driver specific to each browser. Each driver understands the browser’s proprietary logic to control it, making WebDriver faster and more efficient.

WebDriver’s architecture is quite straightforward. It involves your script, written in Python, which communicates commands to the browser-specific driver. The driver then executes these commands within the browser and returns the results back to your script. This interaction facilitates actions like navigating to web pages, selecting elements, and inputting data.

First Selenium Script

Let’s write a basic script to open a web page using Python and Selenium WebDriver. For this example, in this article, we are going to use Google Chrome.

In this article, we are going to do some automations in a web page created by me specifically for this article, that is hosted in ““. 

It is a Job Application Form, without any backend or database, just a frontend that enables us to locate and do some interactions with different web elements, that is the main goal of this article.

Here you have the basic script created:

					# Importing the webdriver module from the selenium package
from selenium import webdriver

# Creating a new instance of the Chrome WebDriver
driver = webdriver.Chrome()

# Navigating to the specified URL with the WebDriver

# Printing the title of the page to the console
print("Title: " + driver.title)

# Closing the WebDriver and quitting the browser

This code snippet is written in Python and utilizes the Selenium WebDriver for automating web browser interactions. Here’s a line-by-line explanation:

					from selenium import webdriver


This line imports the webdriver module from the selenium package. Selenium WebDriver is an essential component of the Selenium suite, which provides a programming interface to create and run web browser sessions.

					driver = webdriver.Chrome()

Here, a new instance of the Chrome WebDriver is created and assigned to the variable driver. This line tells Selenium to open an instance of the Google Chrome browser. 



This line instructs the driver (the Chrome browser you just opened) to navigate to the specified URL. In this case, it’s navigating to ““.

					print("Title: " + driver.title)


This command prints the title of the current page to the console. driver.title retrieves the title of the webpage currently open in the browser controlled by the driver. In this case, it will fetch and print the title of ““.




Finally, driver.quit() closes the entire browser session. It’s important to close the session after automation tasks are completed to free up system resources. Without this line, the browser window will stay open even after the script has finished executing.

You can execute this script simply by running the command:


After running, you will get the below result:

60Dyy8QnWDo7iZMzAiPT7UhNuasSlstrR12XDC6AoRdhiGP1Q8kelM 7lZUiLawNIoqFlKQ0U j 4jRmCAGsTaOqQ97E3Ki7NuuNmTrohwSa8QH0qfFzvsgYB8pAIPQFwUhX20HmcdovMpMf42WAjc

If everything is set up correctly, you will see a Chrome window opening, navigating to the Job Application Form, printing the title of the page in your console, and then closing the browser.

Overall, this script demonstrates a simple Selenium WebDriver usage. This is a fundamental example of web automation using Selenium with Python.

Locating Elements in Selenium with Python

Understanding how to locate elements is a fundamental aspect of using Selenium for web automation. In this section, we’ll explore different types of locators and demonstrate their use with practical examples, using the HTML content of the Job Application Form web page.

Introduction to Locators

In web automation with Selenium, locators are used to find and interact with elements on a web page. The most common types of locators include ID, XPath, and CSS selectors. Each type has its unique way of identifying elements, and choosing the right locator depends on the specific scenario and the structure of the web page.

Learn how to use XPath in Selenium like a pro – different types and practical application! Read the blog now!

  • ID: The simplest and most efficient way to locate elements. Ideal when the element has a unique ID.
  • XPath: A powerful language used for navigating through elements and attributes in an XML document. XPath can be used for both simple and complex HTML structures.
  • CSS Selectors: Used to select elements based on their style. While similar to XPath, they can be more readable and better for performance in some cases.

Practical Examples

To locate an element on a web page, you need to right-click on the element you want and then select the Inspect option.

Using the provided HTML content of the “Job Application Form,” let’s demonstrate how to locate various elements using these three locator types.

Example 1: Locating by ID

The form contains several elements with unique IDs, such as the ‘fullName’ input field. 

KRYRsHx6ZPDULea5TMqtcmBHaM2lg6x33Iwe tPTD u9kdthL9tI3w1jC4l7eFMEGqHs5KLJP2AtB0q29QEPQnLnodf 33raBUu7cDB g6aZ3aOo3sZH aKFjn

Here’s how you can locate this element using its ID:

					driver.find_element(By.ID, "fullName")


Example 2: Locating by XPath

XPath can be used to locate elements with more complex queries. For instance, to find the ‘Submit Application’ button.

ukdpTy7HfFo8 kNH4zk783ekcRp2bS

Here’s how you can locate this element using its XPATH:

					driver.find_element(By.XPATH, "//button[text()='Submit Application']")


This XPath looks for a button element with the text ‘Submit Application’.

Example 3: Locating by CSS Selector

CSS selectors are useful for finding elements based on their styling. For example, you can locate the email input field using its CSS selector.

6fSDWKNHvCQBxqisE WjcKWfWIISg7hzPlloEoxTH MLGM2EduIy9q kAeZZY8FGs25xWMc26Bwi63sdSLM5oTBxQ62eZcCYDXEd6 kMXnOvdsQO21Ncx OM231HjMmcslJcOpvZsWKI0JTn0 mBsYA

Here’s how you can locate this element using its CSS selector:

					driver.find_element(By.CSS_SELECTOR, "input[type='email']")


This CSS selector looks for an input element where the type attribute is ’email’.

Mastering different locator techniques is essential in Selenium automation. The correct choice of locator enhances the stability and maintainability of test scripts, making it a fundamental skill for web automation.

Interacting with Web Elements

In Selenium WebDriver, interacting with various web elements like text boxes, buttons, checkboxes, etc., is a core aspect of automating web applications. This section provides insights into how these elements work, and a practical example in the Job Application Form web page to demonstrate their interaction using Selenium.

Working with Web Elements

Let’s discover some of the existent web elements that you can work with, and how to interact with them.

Text Boxes

Text boxes are commonly used for inputting text data. Selenium allows you to easily enter text using the send_keys() method.


Buttons are used for submitting data, navigating through pages, or triggering specific functionalities. Selenium interacts with buttons using the click() method.


Checkboxes allow users to select one or more options. Selenium can check or uncheck these boxes using the click() method.

Radio Buttons

Similar to checkboxes, but typically used for selecting only one option from a group. Selenium uses the click() method to select a radio button.

Dropdown Menus

Dropdowns or select boxes enable selecting an option from a list. Selenium can interact with dropdown menus using the select_by_visible_text() method from the Select class.

Practical Example

In this section, we will walk through a practical example of using Selenium WebDriver to automate the process of filling out a web form and submitting it. Specifically, we will complete a “Job Application Form,” verify the successful submission, and check for a confirmation message. The form includes various types of inputs: text boxes, radio buttons, checkboxes, a dropdown, and a submission button.

Here’s a Python script using Selenium to automate this form submission:

					# Importing necessary libraries and setting up Selenium WebDriver:
# - selenium.webdriver for controlling the browser
# - By for locating elements
# - Select for selecting an option from a dropbox element
from selenium import webdriver
from import By
from import Select

# Creating a new instance of the Chrome WebDriver
driver = webdriver.Chrome()

# Navigating to the specified URL with the WebDriver

# Filling out the form
driver.find_element(By.ID, "fullName").send_keys("John Doe") # Typing personal full name
driver.find_element(By.ID, "email").send_keys("") # Typing personal e-mail
driver.find_element(By.ID, "phoneNumber").send_keys("1234567890") # Typing personal phone number
Select(driver.find_element(By.ID, "desiredPosition")).select_by_visible_text("Manager") # Selecting 'Manager' as desired position
driver.find_element(By.ID, "location1").click() # Selecting 'Remote' as preferred work location
driver.find_element(By.ID, "experienceYears").send_keys("17") # Typing number of years of experience
driver.find_element(By.ID, "skill1").click() # Checking 'HTML' skill
driver.find_element(By.ID, "skill2").click() # Checking 'CSS' skill

# Submitting the form clicking in the button
driver.find_element(By.ID, "jobApplicationForm").submit()

# Checking the success message and printing it in the console
success_message = driver.find_element(By.ID, "successMessage").text
assert "Submission successful!" in success_message

# Closing the browser

Code Explanation

In the above code, we begin by importing essential libraries to work with Selenium and set up the Chrome WebDriver. These libraries include webdriver for browser control, By for element location, and Select for handling dropdown elements.

					from selenium import webdriver
from import By
from import Select


Next, we create a new instance of the Chrome WebDriver by initializing driver = webdriver.Chrome(). This step prepares us to control the Chrome browser programmatically.

					driver = webdriver.Chrome()

With the WebDriver in place, we instruct it to navigate to a specific URL using driver.get(“”). This line opens the Job Application Form web page where we will interact with the form elements.



The core of the script involves filling out the form. We locate each form field using driver.find_element(By.ID, “element_id”), where element_id is the unique identifier of the form field. We use the send_keys() method to enter text into text fields, the select_by_visible_text() method of the Select class to choose options from a dropdown, and the click() method to interact with radio buttons and checkboxes.

					driver.find_element(By.ID, "fullName").send_keys("John Doe")
driver.find_element(By.ID, "email").send_keys("")
driver.find_element(By.ID, "phoneNumber").send_keys("1234567890")
Select(driver.find_element(By.ID, "desiredPosition")).select_by_visible_text("Manager")
driver.find_element(By.ID, "location1").click()
driver.find_element(By.ID, "experienceYears").send_keys("17")
driver.find_element(By.ID, "skill1").click()
driver.find_element(By.ID, "skill2").click()

After filling out the form, we submit it with driver.find_element(By.ID, “jobApplicationForm”).submit(). This action triggers the submission of the job application form.

					driver.find_element(By.ID, "jobApplicationForm").submit()

To verify the success of the submission, we locate the success message element, retrieve its text using .text, and assert that it contains the expected message “Submission successful!”. If the assertion passes, we print the success message to the console.

					success_message = driver.find_element(By.ID, "successMessage").text
assert "Submission successful!" in success_message

Finally, we close the Chrome browser and terminate the WebDriver session using driver.quit(). This step ensures that resources are properly released after the script’s execution.



Throughout our exploration of Selenium with Python, we have delved into its fundamentals, from the installation and setup to scripting and element interaction. Starting with an introduction to Selenium’s importance in test automation, we progressed through setting up the environment and practicing with essential tasks like locating and interacting with various web elements. This journey provided a comprehensive understanding of how Selenium, combined with Python, became a powerful tool for automating and testing web applications.

As we wrap up, remember that this journey is just the beginning. The skills you have acquired open doors to numerous possibilities in web automation. Continue practicing and applying these skills in real-world scenarios, and stay updated with the latest trends in the field. The road to mastery in Selenium and Python is ongoing, filled with opportunities for growth, innovation, and contribution to the world of Test Automation.


You can find all the code created to this article in this GitHub repository, available at: