Skip to main content

How To Take Screenshots With Python Selenium

Selenium Guide: How To Take Screenshots

Selenium, the powerhouse of web automation, extends its capabilities beyond interaction to capturing the essence of your web journey. In this comprehensive guide, we unveil the art of taking screenshots with Selenium.

At the end of this article, you will learn the techniques to capture dynamic content, document critical states, and enhance your debugging process.

TLDR: How To Capture Screenshots Using Selenium

If you're in a hurry and just need the essentials on Selenium screenshot capture, you're in the right place.

Below, we've outlined the key methods along with concise code snippets to help you capture screenshots effortlessly.

driver.save_screenshot()Save a screenshot of the current viewport.
element.screenshot()Zoom in on target element and capture its visual representation.
driver.get_screenshot_as_file()Capture only the currently visible area of the webpage.
driver.save_full_page_screenshot()Capture full page using the Geckodriver.

1. Capture the Current Viewport

In order to take a screenshot or snapshot of the visible area of a web page that is currently displayed within the browser window:


With this one-liner, we save a screenshot of the current viewport.

2. Capture Specific Elements

You can take screenshots of individual web elements rather than the entire viewport. Zoom in on critical elements by specifying their locator (here, it's an element with ID "someId").

element = driver.find_element(By.ID, "someId")

This captures the visual representation of that particular element, giving you detailed insights.

3. Capture Visible Area

To capture a screenshot of the content currently displayed within the browser window, regardless of whether it is the entire viewport or just a section of it:


The script above captures the screenshot of the visible area, while ignoring the rest.

4. Capture Full Page (Using Selenium-stealth)

To capture the entire web page, including sections that may not be immediately visible, the integration of Selenium-stealth becomes imperative.


This method captures the entire page using the Geckodriver.

And there you have it, a quick guide to Selenium screenshot capture!

If you're ready to dive deeper into each method and explore real-world use cases, let's move on to the next section.

Elaborating on Screenshot Capture Methods

As summarized above, there are four different methods that serve various purposes for taking screenshots in Selenium.

Now, let's delve into the practical details of each method for capturing screenshots with Selenium.

Method 1: Capture the Current Viewport

The "current viewport" refers to the visible area of a web page that is currently displayed within the browser window. In other words, it is the portion of the web page that is visible to the user without scrolling.

This method involves using the save_screenshot function provided by Selenium to capture the current viewport of a web page. It's a quick and straightforward approach to taking a snapshot of what is currently visible on the screen.

from selenium import webdriver
from import Service
from import ChromeDriverManager

driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()))

The save_screenshot function takes a snapshot of the current viewport and saves it as a PNG file named "current_viewport.png". It's a quick and easy way to capture the current viewport of your web journey.

Screenshot of Current Viewport in Books to Scrape

Method 2: Capture Specific Elements

Capturing specific elements in Selenium involves taking targeted screenshots of individual components on a web page. Instead of capturing the entire viewport, this method allows you to focus on particular elements, providing detailed insights for testing or debugging purposes.

This method is useful when precision is essential. It involves using Selenium's find_element method to locate a specific element on the webpage, and then capturing the visual representation of that element using the screenshot function.

from selenium import webdriver
from import Service
from import ChromeDriverManager
from import By

driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()))
element = driver.find_element(By.XPATH, '//*[@id="default"]/div/div/div/div/section/div[2]/ol/li[12]/article/h3/a')

  • Here, we identify an element with the specified XPATH using Selenium's find_element method.
  • Once located, we capture its visual representation with the screenshot function, saving it as "element_screenshot.png".

Screenshot of Specific Elements in Books to Scrape

Method 3: Capture Visible Area

Capturing the visible area in Selenium means taking a screenshot of the content currently displayed within the browser window, irrespective of whether it has the entire viewport or just a section of it.

It employs the get_screenshot_as_file method to capture the screenshot of what is currently displayed on the screen.

from selenium import webdriver
from import Service
from import ChromeDriverManager

driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()))
  • The code snippet initializes a Chrome WebDriver, navigates to the desired webpage, and captures the screenshot of the visible area with driver.get_screenshot_as_file("visible_area.png").
  • The resulting screenshot is saved as "visible_area.png," and the WebDriver is closed using driver.quit().

Screenshot of Visible Area in Books to Scrape

Method 4: Capture Full Page

This method is designed to capture the entire webpage, including content beyond the current viewport.

It uses the save_full_page_screenshot function, which is particularly supported by GeckoDriver (Firefox WebDriver) in this example.

from selenium import webdriver
from selenium.webdriver.firefox.service import Service
from webdriver_manager.firefox import GeckoDriverManager

driver = webdriver.Firefox(service=Service(GeckoDriverManager().install()))

  • In the code snippet, a Firefox WebDriver is initialized, and GeckoDriver is managed using the WebDriver manager.
  • The WebDriver navigates to the specified webpage, and the driver.save_full_page_screenshot("full_page.png") line captures and saves the full page screenshot as "full_page.png."

Screenshot of Full Page in Books to Scrape

These methods offer flexibility to cater to various screenshot needs.

Now, if you're ready to explore additional considerations and real-world use cases, let's move on to the next section. We've got more in store for you!

Handling Screenshots with Different Browsers

Different browsers, with their unique rendering engines, may introduce variations in how web pages are displayed. When handling screenshots in Selenium across different browsers, it's essential to account for differences in rendering, screen resolutions, and page loading speeds.

Let's delve into considerations when dealing with screenshots across various browsers, ensuring a seamless experience in cross-browser testing.

Let's explore how to adapt our screenshot strategies.

1. Browser-Specific Driver Initialization

Initiating the WebDriver correctly is the first step in adapting to different browsers. Use the appropriate WebDriver based on the browser you are testing against.

Example (Chrome):

from selenium import webdriver
from import Service
from import ChromeDriverManager

driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()))

In the above code, we use the Chrome WebDriver and ensure that it is up-to-date using ChromeDriverManager().install().

Example (Firefox):

from selenium import webdriver
from selenium.webdriver.firefox.service import Service
from webdriver_manager.firefox import GeckoDriverManager

driver = webdriver.Firefox(service=Service(GeckoDriverManager().install()))

Similar to Chrome, we use the Firefox WebDriver and ensure it is up-to-date using GeckoDriverManager().install().

2. Handling Browser-Specific Behaviors

Be aware of and account for unique behaviors or capabilities specific to each browser.

Example (Edge):

from selenium import webdriver
from selenium.webdriver.edge.service import Service
from import EdgeChromiumDriverManager

driver = webdriver.Edge(service=Service(EdgeChromiumDriverManager().install()))

In the above code, we specifically initialize the Edge WebDriver and ensure its compatibility with the Chromium-based version using EdgeChromiumDriverManager().

3. Adjusting Waits for Browser Load Times

Different browsers may exhibit varying page load times. Adjust implicit or explicit waits to accommodate these differences.

Example (Implicit Wait):

driver.implicitly_wait(10)  # Adjust the wait time based on browser behavior

Example (Explicit Wait):

from import WebDriverWait
from import expected_conditions as EC

# Adjust the timeout based on browser behavior
wait = WebDriverWait(driver, timeout=10)
element = wait.until(EC.visibility_of_element_located((By.ID, "someId")))

4. Screen Resolution Considerations

Ensure consistent screenshot resolutions across browsers by setting the desired screen resolution.

Example (Chrome):

options = webdriver.ChromeOptions()
options.add_argument("--window-size=1920,1080") # Adjust resolution as needed
driver = webdriver.Chrome(options=options, service=Service(ChromeDriverManager().install()))

Example (Firefox):

options = webdriver.FirefoxOptions()
options.add_argument("--height=1080") # Adjust resolution as needed
driver = webdriver.Firefox(options=options, service=Service(GeckoDriverManager().install()))

By incorporating these adjustments, your Selenium code becomes versatile enough to handle different browsers seamlessly. This adaptability ensures the reliability and effectiveness of your screenshot capture strategies across diverse testing environments.

Why Screenshots Important Are in Selenium

Screenshots play a crucial role in Selenium automation for various reasons, serving beyond mere documentation of web journeys. Understanding the significance of screenshots helps testers and developers leverage this visual tool effectively.

Let's delve into why screenshots are an indispensable aspect of Selenium automation:

  • Visual Record of Test Execution: Screenshots provide a visual record of the actual state of the application at different stages of test execution. This aids in reviewing and verifying the correctness of the application's behavior, especially in complex scenarios.
  • Debugging Aid: In the event of test failures or unexpected behavior, screenshots serve as a valuable debugging aid. They allow testers and developers to visually inspect the state of the application at the point of failure, facilitating quicker identification and resolution of issues.
  • Visual Validation: Screenshots are instrumental in implementing visual validation testing. By capturing screenshots during test execution and comparing them against baseline images, it becomes possible to identify any unintended visual changes, ensuring the UI's consistency.
  • Documentation Enhancement: Automated documentation is greatly enhanced with the inclusion of screenshots. Visual evidence of test scenarios, including expected and actual outcomes, makes documentation more comprehensible and facilitates better communication among team members.
  • Dynamic Content Verification: For applications with dynamic content that loads or changes during user interactions, screenshots capture these dynamic elements in action. This is particularly useful for validating scenarios where content is loaded asynchronously.
  • Collaboration and Reporting: Screenshots serve as effective tools for collaboration and reporting. Visual artifacts are easier to comprehend, making it simpler to communicate issues, improvements, or changes within the development and testing teams.
  • User Journey Visualization: In addition to functional testing, screenshots aid in visualizing the entire user journey. This holistic view helps in understanding the flow and behavior of the application from the end user's perspective.
  • Compliance and Audit Trails: Screenshots contribute to compliance and audit trails by providing a visual representation of the application's state at various checkpoints during test execution. This is crucial for regulatory compliance and quality assurance.

Screenshots Use Cases With Selenium

Screenshots in Selenium are not just a nice-to-have; they are indispensable tools in various scenarios. Here are some common instances where capturing screenshots becomes a crucial aspect of your testing and development process.

1. Visual Validation Testing

Visual validation testing is like having a second pair of eyes, but automated. It involves taking screenshots during test execution and comparing them against baseline images to identify any unexpected changes in the UI.

Let's see how we can integrate this into your workflow.

Code Example:

# Taking a screenshot for visual validation

# Later during testing, capture the current state

# Compare with the baseline
if not compare_images("baseline_image.png", "current_state.png"):
raise AssertionError("UI has unexpected changes!")

compare_images is a placeholder for a function or method that compares two images to determine if they are identical or if there are differences between them. The actual implementation of this function depends on the specific requirements of your testing scenario.

For example, we can implement a basic one as follows:

from PIL import Image #install first `pip install Pillow`
import numpy as np #install first `pip install numpy`

def compare_images(image_path1, image_path2):
# Open the images
img1 =
img2 =

# Convert images to numpy arrays
np_img1 = np.array(img1)
np_img2 = np.array(img2)

# Check if the images have the same shape and content
if np.array_equal(np_img1, np_img2):
return True
return False

In the above code, we define a Python function called compare_images, leveraging the Pillow (PIL) and NumPy libraries to compare two images specified by their file paths. After opening the images using Pillow, we convert them into NumPy arrays, facilitating an efficient element-wise comparison.

The function returns True if the images have identical shapes and content; otherwise, it returns False. This provides a straightforward and effective method for determining image equality in Python.

2. Capturing Dynamic Content

We know web pages aren't static, and Selenium excels at capturing these dynamic elements.

Let's explore techniques to handle dynamically changing content during user interactions.

Code Example:

# Wait for an element to become visible before capturing
element = WebDriverWait(driver, 10).until(
EC.visibility_of_element_located((By.ID, "dynamicElement"))

We utilize Selenium's WebDriverWait to wait up to 10 seconds for an element with the specified ID ("dynamicElement") to become visible on the web page. Once the element is visible, we capture a screenshot of it using the screenshot method and save the image as "dynamic_content.png".

3. Automated Documentation

Automated documentation becomes a breeze, fostering better communication and collaboration within your team. You can enhance your test reports with visual evidence by incorporating screenshots.

Code Example:

# Capture screenshots during critical steps
# Perform actions...
# Continue the test...

We capture screenshots at critical steps during the execution of a Selenium test. The save_screenshot method is used to take snapshots of the current state of the web page, and each screenshot is saved with a distinct filename ("step_1.png" and "step_2.png").

4. Debugging with Screenshots

Screenshots are not just for show; they're powerful tools for debugging. Visual inspection at specific checkpoints can expedite issue identification and resolution.

Let's walk through a step-by-step guide:

Code Example:

# Take a screenshot at the beginning of a test

# Execute test steps...
# Something unexpected happens...
# Capture the current state for investigation

We incorporate a debugging strategy by taking a screenshot at the outset of a Selenium test using driver.save_screenshot("debug_start.png"). Subsequently, as the test steps unfold, if any unexpected behavior occurs, we capture the current state of the web page for further investigation with driver.save_screenshot("debug_issue.png").

5. Test Failures and Unexpected Behavior

Imagine running a Selenium test, and it unexpectedly fails or exhibits unusual behavior. Capturing a screenshot at the moment of failure provides a visual snapshot of the application's state, aiding in rapid identification and debugging.

Code Example:

# Capturing a screenshot on test failure
def test_example():
# Test steps...
if not assertion_condition():
assert False, "Assertion failed!"

We integrate the capture of a screenshot into a test failure scenario within the test_example function. As we execute the test steps, if the specified assertion_condition is not met, signifying a test failure, we use driver.save_screenshot("test_failure.png") to capture a visual representation of the application's state.

This approach ensures that, in case of a test failure, we have a visual aid to expedite diagnosis and issue resolution. Additionally, we assert False and provide a clear failure message for better interpretation of the test results.

Common Challenges with Screenshots in Selenium

Capturing screenshots with Selenium is a powerful feature, but it comes with its own set of challenges. Here are some common hurdles and how to overcome them:

  1. Dynamic Content Rendering: Handling scenarios where content changes dynamically, impacting the accuracy of captured screenshots.
  2. Cross-Browser Consistency: Ensuring consistent screenshot capture across different browsers and platforms.
  3. Efficient File Management: Dealing with a large number of screenshots efficiently, including storage and retrieval.
  4. Visual Validation Thresholds: Defining and maintaining acceptable visual validation thresholds to avoid false positives and negatives.

To overcome these challenges, implement dynamic waits, image comparison techniques, as explained in the previous sections of this article.

Best Practices for Screenshot Management

Capturing screenshots is a powerful feature, but managing them effectively is equally impor tant for a streamlined testing and development process.

Here are some best practices to ensure your screenshot repository remains organized and accessible.

1. Organizing Screenshots

Implement a structured approach to organizing screenshots. Create folders based on test scenarios, features, or modules. This ensures a clear hierarchy and makes it easy to locate specific screenshots when needed.



2. Naming Conventions

Establish a consistent naming convention for your screenshots. Include relevant information such as the test scenario, step, or feature name. This makes it easier to identify the context of each screenshot.



3. Timestamping Screenshots

Automatically timestamp your screenshots to provide a chronological context. This is particularly useful for tracking changes over time and correlating screenshots with specific test runs.



4. Integration with Test Frameworks

Integrate screenshot capture directly into your test framework. This ensures that screenshots are taken consistently at predefined checkpoints during test execution, making them an integral part of your testing process.

Example (pytest):

# Pytest fixture for capturing screenshots
def capture_screenshot(request):

5. Storage Strategies

Consider cloud storage solutions or version control systems for storing screenshots. This ensures accessibility across team members, facilitates collaboration, and provides version history for changes.



6. Conditional Screenshot Capture

Implement logic to conditionally capture screenshots based on specific scenarios or test outcomes. This helps avoid unnecessary clutter while ensuring comprehensive coverage for critical steps.


# Conditional screenshot capture
if test_result == "failed":

By following these best practices, you can establish a robust system for managing your screenshots.

A well-organized and named collection of screenshots not only simplifies debugging and issue resolution but also enhances collaboration within your development and testing teams.


In conclusion, we have simplified the process of capturing snapshots on the web with concise and easy-to-understand code. Our approach involves breaking down technical details while emphasizing the role these snapshots play in simplifying testing.

The guide not only explores resolving issues but also underscores the improvement in teamwork achieved through the use of these quick visual representations.

Going beyond the code, the article emphasizes the significance of these snapshots. We elaborate on how they assist in verifying the proper functioning of elements, troubleshooting problems, and enhancing collaborative efforts.

Equipped with straightforward methods, real-world examples, and a clear understanding of the importance of snapshots, you are well-prepared to excel in Selenium testing and elevate your overall web development journey.

More Web Scraping Guides

Explore additional ScrapeOps guides related to Selenium automation, including: