Recommended Free Tools
Some links on this page are affiliate links: if you buy through them we may earn a commission, at no extra cost to you.
Short answer: Selenium can minimize a headed browser with driver.minimize_window() and save a PNG with driver.save_screenshot(), but Selenium’s documentation does not guarantee that a post-minimize screenshot will contain the page on every browser, driver, window manager, and operating system. If the real requirement is simply to keep the browser invisible, run Selenium in headless mode, set an explicit viewport, and validate the result in the same environment used in production.
This guide shows both workflows, explains what is and is not guaranteed, and provides a practical troubleshooting path.
What Selenium actually guarantees
Selenium’s window documentation supports minimizing the current browsing context in Selenium 4 and later. The command typically hides the window in the system tray, but “the exact behavior of this command is specific to individual window managers.” That means minimizing is a request to the desktop environment, not a promise that the browser will continue painting an ordinary visible surface.
Do these 3 things before closing this tab:
1Fix the driver behind crashes, sound loss and screen glitches2Repair Windows errors before they cause bigger problems3Scan for outdated or missing drivers - takes under a minuteSelenium’s screenshot APIs capture the current browsing context. In Python, save_screenshot(filename) writes PNG data; get_screenshot_as_file(), get_screenshot_as_png(), and get_screenshot_as_base64() provide related forms. The Python API documentation recommends a full path and a filename ending in .png.
#1 Best Overall
The Java TakesScreenshot API explains that conformant drivers follow the WebDriver specification. With non-conformant drivers, capture is best effort and the driver may choose different capture extents. No cited Selenium source publishes a universal success rate for screenshots taken after minimizing.
Choose the workflow that matches your goal
| Workflow | Use it when | Important trade-off |
|---|---|---|
| Minimize a headed browser, then capture | You must keep a real headed session and specifically need the minimize operation. | Window-manager behavior varies, and the official docs do not guarantee the contents of a screenshot taken after minimization. |
| Run headless, then capture | You only need the browser out of view while automation runs. | Headless flags and rendering details depend on installed browser and Selenium versions, so verify viewport behavior. |
Before choosing, answer three questions: must the browser be headed, must the screenshot happen after minimization, and does the target page need a particular responsive layout? If visibility is the only concern, headless mode is usually the more direct fit.
Reliable Python baseline: headless capture
The following program follows Selenium’s documented pattern: configure Chrome options, set a deliberate viewport, navigate, save a PNG, and always quit.
Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Repair Windows errors before they cause bigger problemsFix Now →from selenium import webdriver
options = webdriver.ChromeOptions()
options.add_argument("--headless")
options.add_argument("--window-size=1440,1000")
driver = webdriver.Chrome(options=options)
try:
driver.get("https://example.com")
driver.save_screenshot("/tmp/screenshot.png")
finally:
driver.quit()The dimensions are examples, not a universal standard. Choose dimensions that represent the layout you are testing. A 1440-pixel viewport can produce a desktop navigation bar where a 390-pixel viewport would produce a mobile menu. Record the chosen size alongside your test artifacts so a later comparison is meaningful.
Selenium’s January 2023 guidance, “Headless is Going Away!”, explains that the convenience headless method was deprecated in Selenium 4.8.0 and removed in 4.10.0. Configure browser options with arguments appropriate to your installed browser and Selenium version rather than relying on that removed convenience method.
Wait for the page you intend to capture
driver.get() returns after the navigation strategy’s load condition, but modern pages can continue rendering images, fonts, and client-side components. For deterministic captures, wait for a page-specific condition before calling save_screenshot. For example, wait for a hero element to become visible:
Rank #2
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
# after driver.get(...)
WebDriverWait(driver, 20).until(
EC.visibility_of_element_located((By.CSS_SELECTOR, "main"))
)
driver.save_screenshot("/tmp/ready.png")Use a selector that represents “ready” for your application, not an arbitrary sleep. If the page has a known animation or delayed chart, wait for its final-state class or a bounded delay in addition to the selector.
When minimization is required
If another process, test requirement, or desktop policy requires a headed browser, minimize it explicitly and test the complete sequence in the actual execution environment.
from selenium import webdriver
options = webdriver.ChromeOptions()
options.add_argument("--window-size=1440,1000")
driver = webdriver.Chrome(options=options)
try:
driver.get("https://example.com")
# Confirm the page is ready before changing window state.
driver.minimize_window()
ok = driver.save_screenshot("/tmp/minimized.png")
if not ok:
raise RuntimeError("WebDriver reported that the screenshot could not be saved")
finally:
driver.quit()This code demonstrates the API, not a cross-platform guarantee. Some window managers may leave a minimized surface unavailable to the capture implementation; others may restore, freeze, or otherwise handle the window differently. If the image is blank, stale, clipped, or otherwise wrong, capture before minimizing or switch to headless mode. Do not infer that a successful return value proves that the pixels represent the page you expected.
Capture before minimizing when possible
driver.get("https://example.com")
driver.save_screenshot("/tmp/before-minimize.png")
driver.minimize_window()This preserves a screenshot from the normal headed rendering path while still allowing the session to be hidden afterward. It does not satisfy a requirement that the pixels be captured after minimization, but it avoids making the screenshot depend on desktop window-manager behavior.
Viewport, window, and screenshot scope
- Viewport is not the same as a physical monitor. Browser chrome, device scale, and operating-system display settings can affect the content area. Set a window size and inspect the resulting image rather than assuming the nominal dimensions.
- Responsive breakpoints change the page. A small width can trigger a mobile layout, different menu controls, or hidden content. Keep viewport dimensions fixed across runs when comparing images.
- Ordinary screenshots are not automatically full-page. The standard screenshot call captures the driver’s supported current view. Full-page behavior varies by browser and driver; if you need the entire document, verify the resulting file for your exact versions instead of assuming a full-page image.
- Display access matters for headed sessions. A minimized headed browser still depends on the operating system’s window manager and display configuration. A headless session avoids the visible window but still needs compatible browser and driver binaries.
Common failures and fixes
The file is missing or cannot be written
Use an absolute path, ensure the parent directory exists, and give the file a .png suffix. Check the process user’s write permissions. save_screenshot returns a Boolean in the Python binding; treat a false result as an error and preserve the driver logs.
The screenshot is blank after minimization
This is consistent with the documented limitation: minimize behavior is window-manager-specific, and post-minimize capture is not universally guaranteed. Reproduce on the target operating system and display stack, then capture before minimizing or use headless mode.
The image shows the wrong responsive layout
Set an explicit window size before navigation, keep it constant, and check the actual image dimensions. A window manager can constrain a headed window; headless options can also render differently across browser versions. Test the exact browser, driver, and Selenium versions deployed.
Headless starts but the page differs from headed mode
Compare viewport dimensions, device scale, fonts, GPU-related settings, and page timing. Wait for the same application-ready condition in both modes. Headless mode solves visibility, not visual equivalence; your acceptance criteria should specify which rendering is authoritative.
The screenshot catches a loading spinner or missing images
Replace fixed short sleeps with an explicit wait for the component’s ready state. For lazy-loaded content, scroll or trigger the application’s loading behavior before capture, then wait for the relevant images or containers. Keep the wait bounded so a failed page produces a diagnosable timeout rather than an indefinitely hanging job.
Free tools Windows power users keep installed
One-click scans. No signup required.
The browser or driver cannot start
Confirm that the browser and driver versions are compatible, the executable is available to the runtime user, and the selected headless argument is supported by that browser version. Log the startup exception and versions. Do not silently fall back to a different browser: that can change layout and invalidate visual comparisons.
Concurrent tests overwrite screenshots
Generate unique filenames using a test ID, URL hash, and timestamp, or write each run to an isolated directory. Keep the viewport and browser version in the artifact metadata so failures can be reproduced.
Operational checklist
- Pin or record the Selenium, browser, and driver versions used by the job.
- Choose headless mode unless a headed, post-minimize capture is a real requirement.
- Set an explicit viewport suitable for the page’s responsive breakpoint.
- Navigate to the URL and wait for a page-specific ready condition.
- Capture to an absolute, unique PNG path.
- Verify file existence, byte size, image dimensions, and—where practical—the presence of expected visual content.
- For minimized headed capture, run the test on every supported window manager and operating system; treat the result as environment-specific.
- Always quit the driver in a
finallyblock so failed tests do not leak browser processes.
Or skip the browser setup
If you need a clean website image rather than Selenium-specific interaction, ScreenshotNeo provides a single screenshot request. It accepts the cookie or consent banner like a visitor and removes more than 60 known consent platforms, newsletter popups, and chat widgets before capture; each cleanup step can be turned off. Bot checks or CAPTCHAs, blank pages, timeouts, failed loads, and cache hits are not billed, and the response identifies the outcome with X-Page-Verdict and X-Billed headers.
See the complete parameter reference in the ScreenshotNeo documentation. A cURL request:
The Tool Desk
Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpThe same request in Python:
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)And Node.js:
const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);ScreenshotNeo also offers an MCP server with take_screenshot, get_page_info, and capture_pdf tools for Claude, Cursor, and other MCP clients. It supports full-page captures with lazy images loaded, CSS-selector element captures, dark mode, device presets and custom viewports, retina scale, PDFs, custom CSS and JavaScript, clicks, selector or network-idle waits, request blocking, headers, cookies, user agents, authorization, timezone and geolocation, transparent backgrounds, resizing, TTL caching, signed links, asynchronous webhooks, bulk capture of up to 100 URLs per call, a usage API, and an OpenAPI specification.
The Free plan includes 1,000 screenshots per month with no card. Paid plans start at $5 for 3,000 shots; every feature is available on every plan, and yearly billing gives two months free. Create a free ScreenshotNeo account to try it without a card.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Cost, reliability, and maintenance considerations
Selenium has no per-screenshot service charge, but you maintain browser binaries, drivers, operating-system dependencies, display configuration, storage, retries, and cleanup. Headed minimization adds another environment variable: the window manager. Headless execution removes the visible window but still requires version and rendering validation.
For a small test suite, local Selenium can be straightforward. For scheduled or high-volume captures, isolate jobs, cap navigation and wait timeouts, retain failure screenshots and logs, and retry only transient startup or network failures. A retry cannot fix a deterministic blank capture caused by a minimized-window limitation; change the capture strategy instead. If you use a remote screenshot service, inspect its per-response status headers and cache behavior so billing and failed-page handling are explicit.
FAQ
Does minimize_window() make Selenium headless?
No. It remains a headed browser controlled by the operating system’s window manager. Headless mode starts the browser without a visible window.
Can I save a JPEG with Selenium’s Python screenshot method?
save_screenshot() writes PNG data. Convert the resulting PNG separately if another format is required.
Best Value
Which viewport should I use?
Use the dimensions required by the responsive layout you are validating, and keep them fixed for comparable runs. There is no single correct size for every site.
Is a successful API return proof that the minimized screenshot is correct?
No. The file can be written even when the pixels are blank or otherwise unsuitable; inspect the image in the target environment.
Frequently Asked Questions
Does minimize_window() make Selenium headless?
No. It remains a headed browser controlled by the operating system’s window manager. Headless mode starts the browser without a visible window.
Can I save a JPEG with Selenium’s Python screenshot method?
save_screenshot() writes PNG data. Convert the resulting PNG separately if another format is required.
Which viewport should I use?
Use the dimensions required by the responsive layout you are validating, and keep them fixed for comparable runs. There is no single correct size for every site.
Is a successful API return proof that the minimized screenshot is correct?
No. The file can be written even when the pixels are blank or otherwise unsuitable; inspect the image in the target environment.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
