Website Screenshots with Selenium in Python

Selenium is one of the oldest browser automation tools, and it’s still widely used. If you already have Selenium in your stack, you can take screenshots without adding another dependency. Let me quickly show you how.

If you don’t want to read and just save time,I created a dedicated repository with tested and working examples of how to take screenshots with Selenium in Python.

However, if you don’t use Selenium and building from scratch, I recommend using Playwright instead, it is a modern and actively developed library for browser automation. Especially if that’s the only functionality you need. Or check out our guide to how to take website screenshots Python.

Quick Start

Install Selenium and webdriver-manager:

1
pip install selenium webdriver-manager

Using webdriver-manager eliminates the need to manually download ChromeDriver:

1
from selenium import webdriver
2
from selenium.webdriver.chrome.service import Service as ChromeService
3
from webdriver_manager.chrome import ChromeDriverManager
4

5
# automatically download and use the correct ChromeDriver
6
driver = webdriver.Chrome(service=ChromeService(ChromeDriverManager().install()))
7

8
driver.get('https://example.com')
9
driver.save_screenshot('screenshot.png')
10
driver.quit()

If you are familiar with example.com, you should not be surprised by the result:

A screenshot of the example.com website

Screenshot Methods

Selenium provides three ways to capture screenshots:

1. Save to File

1
driver.save_screenshot('screenshot.png')

2. Get as Bytes (PNG)

1
png_bytes = driver.get_screenshot_as_png()
2

3
# Save manually
4
with open('screenshot.png', 'wb') as f:
5
    f.write(png_bytes)

3. Get as Base64 String

1
base64_string = driver.get_screenshot_as_base64()
2

3
# Useful for embedding in HTML or sending via API
4
import base64
5
png_bytes = base64.b64decode(base64_string)

Waiting for Page Load

Taking a screenshot too early means incomplete content:

Explicit Wait for Elements

1
from selenium.webdriver.support.ui import WebDriverWait
2
from selenium.webdriver.support import expected_conditions as EC
3
from selenium.webdriver.common.by import By
4

5
driver.get('https://example.com')
6

7
# Wait for specific element to be visible
8
wait = WebDriverWait(driver, 10)
9
wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, '.main-content')))
10

11
driver.save_screenshot('screenshot.png')

Fixed Timeout

1
import time
2

3
driver.get('https://example.com')
4
time.sleep(3)  # Wait 3 seconds
5
driver.save_screenshot('screenshot.png')

Combine Both

1
from selenium.webdriver.support.ui import WebDriverWait
2
from selenium.webdriver.support import expected_conditions as EC
3
from selenium.webdriver.common.by import By
4
import time
5

6
driver.get('https://example.com')
7

8
# Wait for main content
9
try:
10
    wait = WebDriverWait(driver, 10)
11
    wait.until(EC.presence_of_element_located((By.TAG_NAME, 'body')))
12
except:
13
    pass
14

15
# Extra buffer for JavaScript
16
time.sleep(1)
17

18
driver.save_screenshot('screenshot.png')

Element Screenshots

Capture a specific element instead of the full viewport:

1
from selenium.webdriver.common.by import By
2

3
driver.get('https://example.com')
4

5
# Find element and screenshot it
6
element = driver.find_element(By.CSS_SELECTOR, '.hero-section')
7
element.screenshot('hero.png')

Viewport Settings

Control the browser window size:

1
# Set window size before navigating
2
driver.set_window_size(1920, 1080)
3
driver.get('https://example.com')
4
driver.save_screenshot('screenshot.png')

Or maximize:

1
driver.maximize_window()

Full Page Screenshots

This is where Selenium falls short. Unlike Playwright, Selenium doesn’t have native full-page support. Here’s the workaround:

1
from selenium import webdriver
2
from selenium.webdriver.chrome.options import Options
3
from PIL import Image
4
import io
5
import time
6

7
def full_page_screenshot(driver, output_path, scroll_wait):
8
    metrics = driver.execute_script(
9
        """
10
        const body = document.body;
11
        const html = document.documentElement;
12
        const totalHeight = Math.max(
13
            body.scrollHeight, body.offsetHeight, body.clientHeight,
14
            html.scrollHeight, html.offsetHeight, html.clientHeight
15
        );
16
        const viewportHeight = window.innerHeight;
17
        return { totalHeight, viewportHeight };
18
        """
19
    )
20
    total_height = int(metrics["totalHeight"])
21
    viewport_height = int(metrics["viewportHeight"])
22
    if viewport_height <= 0:
23
        raise RuntimeError("Viewport height is zero")
24
    last_scroll = max(total_height - viewport_height, 0)
25
    positions = list(range(0, total_height, viewport_height))
26
    if not positions or positions[-1] != last_scroll:
27
        positions.append(last_scroll)
28
    screenshots = []
29
    for offset in positions:
30
        driver.execute_script(
31
            "document.documentElement.scrollTo(0, arguments[0]);"
32
            "document.body.scrollTo(0, arguments[0]);",
33
            offset,
34
        )
35
        time.sleep(scroll_wait)
36
        png = driver.get_screenshot_as_png()
37
        screenshots.append(Image.open(io.BytesIO(png)))
38
    if not screenshots:
39
        raise RuntimeError("No screenshots captured")
40
    scale = screenshots[0].height / viewport_height
41
    total_height_px = int(total_height * scale)
42
    total_width_px = screenshots[0].width
43
    stitched = Image.new("RGB", (total_width_px, total_height_px))
44
    y = 0
45
    for img in screenshots:
46
        remaining = total_height_px - y
47
        if remaining <= 0:
48
            break
49
        if img.height > remaining:
50
            img = img.crop((0, 0, img.width, remaining))
51
        stitched.paste(img, (0, y))
52
        y += img.height
53
    stitched.save(output_path)
54

55
options = Options()
56
options.add_argument('--headless')
57
driver = webdriver.Chrome(options=options)
58
driver.set_window_size(1920, 1080)
59
driver.get('https://screenshotone.com')
60
full_page_screenshot(driver, 'fullpage.png', 0.2)
61
driver.quit()

It did screenshot the full page, but it had some issue. E.g. it screenshots scrollbar, you can try to fix that by executing the following JavaScript code:

1
document.body.style.overflow = "hidden";

Another issue was that the top navigation bar appeared in the screenshot a few times:

A screenshot of the screenshotone.com website with the top navigation bar appearing in the screenshot a few times

There are many ways to fix that:

Try to fixate all the elements.
Do not stitch pages together, but take a screenshot of the whole page by applying different techniques. However that will also have its own issues.

But unfortunately, it is out of the scope of this guide. Check out our Playwright (Python) guide to how to take full page screenshots for some examples on that can be solved.

If full-page screenshots is a critical part of your workflow, consider using our API instead.

Headless Mode

For server environments:

1
from selenium import webdriver
2
from selenium.webdriver.chrome.options import Options
3

4
options = Options()
5
options.add_argument('--headless')
6
options.add_argument('--no-sandbox')
7
options.add_argument('--disable-dev-shm-usage')
8
options.add_argument('--disable-gpu')
9
options.add_argument('--window-size=1920,1080')
10

11
driver = webdriver.Chrome(options=options)
12
driver.get('https://example.com')
13
driver.save_screenshot('screenshot.png')
14
driver.quit()

Chrome Options for Screenshots

Useful options for screenshot automation:

1
options = Options()
2
options.add_argument('--headless')
3
options.add_argument('--window-size=1920,1080')
4
options.add_argument('--hide-scrollbars')
5
options.add_argument('--force-device-scale-factor=2')  # Retina
6
options.add_argument('--lang=en-US')
7
options.add_argument('--disable-extensions')

Error Handling

1
from selenium import webdriver
2
from selenium.common.exceptions import TimeoutException, WebDriverException
3
from selenium.webdriver.support.ui import WebDriverWait
4
from selenium.webdriver.support import expected_conditions as EC
5
from selenium.webdriver.common.by import By
6

7
def safe_screenshot(url, output_path):
8
    driver = None
9
    try:
10
        driver = webdriver.Chrome()
11
        driver.set_window_size(1920, 1080)
12

13
        driver.get(url)
14

15
        # Wait for page
16
        wait = WebDriverWait(driver, 10)
17
        wait.until(EC.presence_of_element_located((By.TAG_NAME, 'body')))
18

19
        driver.save_screenshot(output_path)
20
        return True
21

22
    except TimeoutException:
23
        print(f"Timeout loading {url}")
24
        return False
25
    except WebDriverException as e:
26
        print(f"WebDriver error: {e}")
27
        return False
28
    finally:
29
        if driver:
30
            driver.quit()

Multiple Screenshots

Process multiple URLs:

1
from selenium import webdriver
2
from selenium.webdriver.chrome.options import Options
3

4
urls = [
5
    'https://example.com',
6
    'https://github.com',
7
]
8

9
options = Options()
10
options.add_argument('--headless')
11

12
driver = webdriver.Chrome(options=options)
13
driver.set_window_size(1920, 1080)
14

15
for i, url in enumerate(urls):
16
    try:
17
        driver.get(url)
18
        driver.implicitly_wait(5)
19
        driver.save_screenshot(f'screenshot_{i}.png')
20
        print(f'Success: {url}')
21
    except Exception as e:
22
        print(f'Failed: {url} - {e}')
23

24
driver.quit()

Check our guide how to take bulk screenshots with Selenium in Python for more details.

Playwright vs Selenium for Screenshots

Feature	Selenium	Playwright
Native full page	No	Yes
Async support	No	Yes
Element screenshots	Yes	Yes
Wait mechanisms	Explicit only	Multiple options
Setup complexity	Higher	Lower
Speed	Slower	Faster

My recommendation: If you’re starting fresh, use Playwright. If you already have Selenium in your project, it works fine for basic screenshots.

When to Use a Screenshot API

Selenium is fine for small volumes, but at scale:

Browser process management becomes complex.
Memory leaks are common.
No native full-page support.

The best use case for that is when you perform testing of your websites: your run and screenshot pages and then close the browser and forget about resources. In that case, resource management is less of an issue.

For production workloads, consider a screenshot API like ScreenshotOne. See the main Python screenshot guide for all options.

Summary

Selenium screenshot basics:

Use save_screenshot() for simple saves
Use webdriver-manager to avoid driver management.
Always wait for content before capturing.
Full page requires workarounds (body element or scroll+stitch).
Use headless mode for servers.

Frequently Asked Questions

If you read the article, but still have questions. Please, check the most frequently asked. And if you still have questions, feel free reach out at support@screenshotone.com.

How to take screenshot in Selenium Python?

Use driver.save_screenshot('screenshot.png') to save directly to file, or driver.get_screenshot_as_png() to get the screenshot as bytes for further processing.

How to take full page screenshot in Selenium Python?

Selenium doesn't have native full page support. You need to scroll through the page, capture sections, and stitch them together. Or use the body element screenshot method in headless mode.

What is the difference between save_screenshot and get_screenshot_as_png?

save_screenshot() saves directly to a file, while get_screenshot_as_png() returns the image as bytes. Use get_screenshot_as_png() when you need to process the image in memory.

Website Screenshots with Selenium in Python

Written by

Published on

Tags