How to Wait for a Specific Element Before Taking a Selenium Screenshot

Use a Selenium explicit wait for the exact element state your screenshot requires, then pass the returned element to element.screenshot(). For example, wait until the element is visible before saving a PNG:

from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.wait import WebDriverWait

locator = (By.CSS_SELECTOR, "#target")
element = WebDriverWait(driver, 10).until(
    EC.visibility_of_element_located(locator)
)
element.screenshot("target.png")

The 10-second timeout is an example; choose a limit appropriate for your application and test environment. Element screenshots contain the target element. To capture the browser viewport instead, wait for the element and call driver.save_screenshot("page.png").

1. Set up Selenium and load the page

Install the Python binding with pip. Selenium Manager can manage browser drivers for supported setups when you create a driver instance.

python -m pip install selenium

from selenium import webdriver

with webdriver.Chrome() as driver:
    driver.get("https://example.com")
    # Add the explicit wait and screenshot code here.

Run this where the browser can start. In a headless or remote test environment, make sure the browser is installed, its dependencies are available, and your Selenium setup is configured for that environment.

2. Wait for the right condition

A navigation reaching its page-load state does not guarantee that JavaScript-driven content has appeared. Wait on the state that makes the intended screenshot meaningful:

Presence alone is not enough if the element is hidden, covered, or still awaiting content. Visibility is a better starting condition for an element screenshot. If the application updates the element after displaying it, wait for the relevant text or state too.

3. Capture the element or the viewport

Capture just the element

WebDriverWait.until() returns the truthy result from its condition. Visibility conditions return the matched element, so you can use that object directly:

from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.wait import WebDriverWait

locator = (By.CSS_SELECTOR, "#target")
element = WebDriverWait(driver, 10).until(
    EC.visibility_of_element_located(locator)
)
element.screenshot("target.png")

The element screenshot API saves a PNG. Selenium also provides element screenshot methods for PNG bytes and base64 output if you need to store or process the data in memory.

Capture the whole viewport

Use a driver-level screenshot method when the output should show the current browser viewport, not a crop of the element. Keep the explicit wait so the target is ready before the capture:

element = WebDriverWait(driver, 10).until(
    EC.visibility_of_element_located((By.CSS_SELECTOR, "#target"))
)
driver.save_screenshot("viewport.png")

The element variable confirms the wait succeeded; the driver method captures the viewport. These are distinct outputs. Do not assume an element screenshot is a full-page screenshot.

4. Use a stronger application-specific readiness check

When visibility happens before the useful content is ready, wait for an app-specific signal. For example, if a result element starts with a loading label and changes to a known final label:

from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.wait import WebDriverWait

locator = (By.CSS_SELECTOR, "#result")
wait = WebDriverWait(driver, 15)
wait.until(EC.visibility_of_element_located(locator))
wait.until(EC.text_to_be_present_in_element(locator, "Results loaded"))
element = driver.find_element(*locator)
element.screenshot("results.png")

If the application publishes a stable completion attribute, check that attribute instead of relying on text. A custom condition can return the element once the state is ready:

from selenium.webdriver.common.by import By
from selenium.webdriver.support.wait import WebDriverWait

def element_ready(driver):
    element = driver.find_element(By.CSS_SELECTOR, "#result")
    if element.is_displayed() and element.get_attribute("data-state") == "ready":
        return element
    return False

element = WebDriverWait(driver, 15).until(element_ready)
element.screenshot("results.png")

Use a completion signal that reflects the content you intend to capture. Waiting for an unrelated element or merely for navigation completion can still produce an early image.

5. Choose timeout and polling behavior

WebDriverWait takes a timeout and an optional polling interval. Its default polling interval is 0.5 seconds, and by default it ignores NoSuchElementException while checking. until() returns the condition’s truthy result or raises TimeoutException when the condition does not become true in time.

wait = WebDriverWait(driver, timeout=12, poll_frequency=0.25)
element = wait.until(
    EC.visibility_of_element_located((By.CSS_SELECTOR, "#target"))
)

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webp

import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"}, timeout=90)
open("shot.webp", "wb").write(r.content)

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);
if (!res.ok) throw new Error(`Screenshot request failed: ${res.status}`);
const fs = await import('node:fs/promises');
await fs.writeFile('shot.webp', Buffer.from(await res.arrayBuffer()));