Free tools Windows power users keep installed
One-click scans. No signup required.
Use a browser automation library, not an operating-system screen-grab API. A Rust Playwright binding can open Chromium, navigate to a URL, set full_page(true), and return the complete scrollable page as image bytes. Save those bytes as PNG or JPEG. The same workflow can be implemented with the lower-level headless_chrome crate when you need direct Chrome DevTools Protocol control.
What “full-page” means in Rust
A normal screenshot captures only the current viewport. A full-page screenshot asks the browser to render the document’s entire scrollable height, as if the page were displayed on a screen tall enough to contain it. Browser tabs, the address bar, and other browser chrome are not included because the APIs capture a page or tab, not the desktop.
Use browser automation when the page contains responsive layout, JavaScript, web fonts, lazy images, authenticated content, or CSS that changes with viewport size. An OS-level capture tool sees only pixels currently displayed and cannot reliably produce the complete document.
Recommended approach: Playwright bindings
Playwright exposes a high-level page model and a direct full-page option. The Rust examples below use the playwright_rs API shown in its documentation. Crate and browser-install steps are release-sensitive: version labels observed for Playwright-related crates included playwright 0.0.20 and playwright-rs 0.15.1/0.14.0. Pin a version that matches your project and follow that release’s installation instructions.
Windows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallOutdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware match#1 Best Overall
- Read Before You Buy — No Video Output: These adapters support charging and USB 2.0 data transfer, but cannot transmit video signals. Except for standard USB webcams (which use USB data only), they are not compatible with HDMI/DisplayPort cables, video-capable USB-C hubs, or docking stations with video output.
- Convert USB-A Ports to USB-C: Designed to connect USB-C earphones, cables, flash drives, card readers, and other USB-C accessories to standard USB-A ports. Plug-and-play with no drivers or software required.
- Aluminum Alloy Housing: Built with a sturdy aluminum alloy shell that aids in heat dissipation and protects against daily wear and scratches. Designed to maintain a stable and secure connection.
- Compact & Travel-Friendly: The ultra-compact design allows the adapter to stay plugged into your device without blocking adjacent ports or adding bulk, reducing wear and tear on your original USB ports.
- 12-Month Warranty: Backed by a 12-month manufacturer warranty for peace of mind. Designed to meet strict quality control standards for reliable everyday performance.
Prerequisites
- A Rust toolchain with Tokio enabled for asynchronous code.
- A Chromium-compatible browser installed or downloaded by the Playwright setup used by your chosen crate version.
- Network access to the target page, plus credentials or headers if the page is private.
Complete PNG example
use playwright_rs::protocol::{Playwright, ScreenshotOptions};
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let playwright = Playwright::launch().await?;
let browser = playwright.chromium().launch().await?;
let page = browser.new_page().await?;
page.goto("https://example.com", None).await?;
let options = ScreenshotOptions::builder()
.full_page(true)
.build();
let png_bytes = page.screenshot(Some(options)).await?;
std::fs::write("full-page.png", png_bytes)?;
browser.close().await?;
Ok(())
}full_page defaults to false; setting it to true changes the capture from the visible viewport to the full scrollable page. The screenshot call returns a byte buffer, so the file extension should match the format you request or the API’s default.
Choosing PNG or JPEG
- PNG: lossless and usually the safest choice for text, diagrams, UI controls, and pixel comparisons.
- JPEG: smaller for photographic pages, but lossy. Use the quality option exposed by your binding when you accept compression artifacts.
There is no universal quality value that is correct for every page. Validate legibility and file size with your own content.
Controlling viewport and clipping
Full-page capture uses the page’s layout viewport and expands the output to the document’s scrollable dimensions. Set the viewport before navigation when responsive breakpoints matter; otherwise a desktop or mobile layout may be selected unexpectedly. Use a clip or element screenshot only when you deliberately want a region rather than the entire document. The Rust Playwright examples expose format, quality, clipping, and byte-buffer controls, but exact builder names can vary by crate release.
Making dynamic pages capture correctly
Calling goto and immediately taking a screenshot is sufficient for a static page, but it is not a readiness definition for an application. Decide what “ready” means for your page and wait for that condition.
Do these 3 things before closing this tab:
1Scan for outdated or missing drivers - takes under a minute2Clear out junk files and repair common Windows errors3Fix the driver behind crashes, sound loss and screen glitchesWait for application content
- Wait for a page-specific selector that appears after the main render.
- Wait for a known delay only when the site has no reliable selector; fixed sleeps are less robust.
- Wait for network activity to settle when the page’s data-loading pattern makes that meaningful.
Use the wait APIs provided by your binding and fail with a useful timeout message. A navigation success does not prove that client-rendered charts, comments, or product data are complete.
Rank #2
- 5-in-1 USB-C Hub: Experience comprehensive connectivity featuring a Power Delivery input, two USB-A 2.0 ports, a USB-A 3.0 port, and an HDMI port. (Note: The USB-C power delivery input port is only for connecting an external wall charger to power your laptop and cannot power peripheral devices.)
- 90W Pass-Through Charging: Achieve optimal charging with 90W pass-through power to your laptop, supported by a total input of 100W, with the hub reserving 10W for operational efficiency. (Note: Wall charger not included.)
- Quick Data Transfers: Accelerate your productivity with rapid data transfers using a high-speed 5Gbps USB 3.0 port and two 480Mbps USB 2.0 ports.
- 4K HDMI Display: Enhance your visual experience with a hub capable of delivering 4K resolution at 30Hz in both mirror and extend modes. Please note that this hub is compatible with MacBook (macOS 12 and newer), Windows 10 and 11, ChromeOS, and laptops equipped with DP Alt Mode and Power Delivery. Note: This device is not compatible with Linux.
- What You Get: Anker USB-C Hub (5-in-1, 4K HDMI), welcome guide, 18-month warranty, and our friendly customer service.
Handle lazy-loaded images
Many pages load images only as they approach the viewport. A full-page request does not guarantee that every lazy resource has been triggered. Before the final screenshot, scroll through the document in increments or invoke the site’s own “load more” behavior, then wait for image elements to finish. The exact JavaScript and waiting logic is site-specific; do not assume one universal lazy-load strategy.
Stabilize visual output
- Disable or pause animations and transitions if you need repeatable pixel output.
- Hide blinking carets and transient notifications where your test permits it.
- Decide whether ads, personalization, consent dialogs, and chat launchers belong in the artifact.
- Use a consistent viewport, timezone, locale, user agent, and account state for comparisons.
Browser screenshot APIs expose controls, but they cannot guarantee deterministic rendering for arbitrary third-party sites. Fonts, ad auctions, remote scripts, and personalized data can still change between runs.
Alternative: direct Chrome control with headless_chrome
headless_chrome is a higher-level Rust API over Chrome or Chromium’s DevTools Protocol. It is a good fit when your application already uses CDP-level operations or you need protocol-oriented control instead of Playwright’s page abstraction. Its capture method accepts a boolean for full-page output.
use headless_chrome::{Browser, protocol::page::CaptureScreenshotFormatOption};
fn main() -> Result<(), Box<dyn std::error::Error>> {
let browser = Browser::default()?;
let tab = browser.wait_for_initial_tab()?;
tab.navigate_to("https://example.com")?;
tab.wait_until_navigated()?;
let jpeg_data = tab.capture_screenshot(
CaptureScreenshotFormatOption::Jpeg,
None,
None,
true,
)?;
std::fs::write("full-page.jpeg", jpeg_data)?;
Ok(())
}The crate documentation lists full-page and element screenshots. The trade-off is that you work closer to Chrome’s protocol, so navigation, readiness, authentication, and error handling are more explicitly your responsibility.
Playwright versus headless_chrome
| Decision point | Playwright Rust bindings | headless_chrome |
|---|---|---|
| Abstraction | High-level browser, context, and page model | Higher-level wrapper around direct CDP operations |
| Full-page control | Explicit full_page(true) screenshot option |
Boolean argument to capture_screenshot |
| Best fit | Tests and workflows that need page-oriented automation | Projects already built around Chrome DevTools Protocol control |
| Output handling | Returned bytes; examples demonstrate PNG, JPEG, clipping, and quality controls | Returned bytes; examples demonstrate JPEG and full-page capture |
| Browser footprint | Requires a compatible Chromium installation or managed browser | Requires Chrome or Chromium accessible to the CDP client |
| Dynamic-page work | You still define waits and lazy-load handling | You still define waits and lazy-load handling, generally at a lower protocol level |
Neither library removes the need to control the page’s state. Choose the API that matches the rest of your automation code and the browser lifecycle you can operate reliably.
Rank #3
- Sleek 7-in-1 USB-C Hub: Features an HDMI port, two USB-A 3.0 ports, and a USB-C data port, each providing 5Gbps transfer speeds. It also includes a USB-C PD input port for charging up to 100W and dual SD and TF card slots, all in a compact design.
- Flawless 4K@60Hz Video with HDMI: Delivers exceptional clarity and smoothness with its 4K@60Hz HDMI port, making it ideal for high-definition presentations and entertainment. (Note: Only the HDMI port supports video projection; the USB-C port is for data transfer only.)
- Double Up on Efficiency: The two USB-A 3.0 ports and a USB-C port support a fast 5Gbps data rate, significantly boosting your transfer speeds and improving productivity.
- Fast and Reliable 85W Charging: Offers high-capacity, speedy charging for laptops up to 85W, so you spend less time tethered to an outlet and more time being productive.
- What You Get: Anker USB-C Hub (7-in-1), welcome guide, 18-month warranty, and our friendly customer service.
Production checklist
- Fix the browser and crate versions used in CI; release metadata and installation behavior change over time.
- Set an explicit viewport and output format.
- Navigate and wait for a page-specific ready condition.
- Trigger lazy content and verify that important images are loaded.
- Freeze or remove animations, popups, and other transient elements when reproducibility matters.
- Capture and persist the returned bytes, checking that the destination directory is writable.
- Close the page and browser on success and on error so repeated jobs do not leak processes.
- Record the URL, viewport, browser version, and capture options alongside artifacts when screenshots are used for tests or audits.
Troubleshooting full-page Rust screenshots
Only the visible viewport is saved
Cause: the full-page flag was omitted, remained at its default false, or the wrong screenshot method was called. Fix: build ScreenshotOptions with .full_page(true), or pass true as the final argument to capture_screenshot.
The page is cut off or content is missing
Cause: lazy loading, infinite scroll, or client-side rendering had not completed. Fix: scroll or trigger the application’s loading mechanism, wait for the relevant selector or images, and capture only after the page reaches a defined ready state.
The screenshot contains a cookie banner or chat widget
Cause: those elements are part of the page DOM at capture time. Fix: accept or dismiss the consent UI in your automation, hide known selectors with page-specific code, or use a capture service that handles common overlays before rendering.
Navigation times out
Cause: slow origin servers, blocked resources, redirects, authentication, or a page that never reaches the library’s chosen load condition. Fix: verify the URL from the same machine, provide required credentials or headers, choose an appropriate wait condition, and keep a bounded timeout with diagnostic logging.
Chromium cannot launch
Cause: the browser executable is missing, incompatible, or blocked by the runtime environment. Fix: install the browser required by your crate release, check executable permissions and sandbox policy, and run the smallest launch-and-navigate program before debugging screenshot options.
Rank #4
- Dual Converters, Infinite Potential：Includes 2× USB C male to USB A female adapters and 2× USB A male to USB C female adapters. Perfect for a wide range of uses—tablets with Bluetooth keyboards, expand USB ports on macbook, and more. Two different converters for all your daily needs
- Next-Level 10Gbps & 3A Charging: No more slow 480Mbps, this usb to usb c adapter has a transfer speed of up to 10Gbps, allowing you to do more transferring in less time. This usb adapter fits both USB A and USB C charger, supporting up to 3A fast charging
- Upgraded Exquisite Craftsmanship: With an aluminum alloy housing and metal connector, the usbc to usb adapter is extremely durable and sturdy. Rigorously tested to withstand more than 10,000 times of plugging and unplugging, ensuring long-lasting performance
- Broad Compatible: The usb c to usb adapter widely supports all USB C/ USB A devices like laptops, tablets, cellphones, car chargers, and phone chargers. Such as compatible with MacBook Pro/Air 2023/2022, Thunderbolt 4/3 Devices,Apple MagSafe Watch 9/8/7/SE/Ultra, iPad Pro 2022/2021, Samsung Galaxy S23/S20/S10, and iPhone 17/16/15 Pro. Plug and play
- Please Note: To reach 10Gbps speed, keep the cable under 3.3 ft. For USB A Male to USB C adapters, try flipping the USB C connector. USB C Male to USB A adapters support bidirectional 10Gbps transfer within 3.3 ft
Output is unexpectedly huge
Cause: a very tall document, high device scale factor, or a large lossless PNG. Fix: use a deliberate viewport and scale, capture JPEG when artifacts are acceptable, or resize after capture. Do not reduce dimensions if the image must remain readable for review or OCR.
Performance, reliability, and cost considerations
Full-page rendering costs more than a viewport shot because the browser must lay out and paint a taller surface and may load additional resources. Reuse a browser process for batches instead of launching one browser per URL, but isolate pages or contexts when cookies and authentication must not leak between jobs. Put timeouts around navigation, readiness waits, and the screenshot itself. Retry transient network failures with a limit; repeated retries cannot fix a deterministic JavaScript error or a permanently blocked bot check.
For test suites, compare images only after normalizing viewport, fonts, locale, timezone, and account data. For archival captures, retain the original bytes and metadata rather than repeatedly recompressing the image. PNG is generally the safer archival format for interface text; JPEG can reduce transfer and storage size when small artifacts are acceptable.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Or skip the browser setup
ScreenshotNeo is a website screenshot API and MCP server. Its full-page capture loads lazy images, and a single GET request returns PNG, JPEG, WebP, or PDF bytes. Before capture it accepts the cookie or consent banner like a visitor and removes more than 60 known consent platforms, newsletter popups, and chat widgets; each step can be turned off. Bot checks and CAPTCHAs, blank pages, timeouts, failed loads, and cache hits are not billed, and response headers identify the page verdict and whether the request was billed.
Use the API directly from Rust or any HTTP client. The parameter names used by other screenshot APIs also work, which can simplify migration. Full options include CSS-selector element capture, dark mode, device presets and arbitrary viewports, retina scale, custom CSS and JavaScript, clicks, selector or network-idle waits, ad/tracker/request blocking, headers, cookies, user agents, authorization, timezone, geolocation, transparent backgrounds, resizing, selectable cache TTLs, signed image links, asynchronous jobs with signed webhooks, bulk capture of up to 100 URLs per call, a usage API, and an OpenAPI specification. An MCP server exposes take_screenshot, get_page_info, and capture_pdf to Claude, Cursor, and other MCP clients.
cURL
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpRust with reqwest
use reqwest::Client;
use tokio::fs;
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let client = Client::new();
let bytes = client
.get("https://api.screenshotneo.com/v1/shot")
.query(&[("access_key", "YOUR_API_KEY"), ("url", "https://stripe.com")])
.send()
.await?
.error_for_status()?
.bytes()
.await?;
fs::write("shot.webp", &bytes).await?;
Ok(())
}See the ScreenshotNeo documentation for option names, response headers, formats, PDF settings, asynchronous jobs, and authentication details.
Best Value
- 5-in-1 Connectivity: Equipped with a 4K HDMI port, a 5 Gbps USB-C data port, two 5 Gbps USB-A ports, and a USB C 100W PD-IN port. Note: The USB C 100W PD-IN port supports only charging and does not support data transfer devices such as headphones or speakers.
- Powerful Pass-Through Charging: Supports up to 85W pass-through charging so you can power up your laptop while you use the hub. Note: Pass-through charging requires a charger (not included). Note: To achieve full power for iPad, we recommend using a 45W wall charger.
- Transfer Files in Seconds: Move files to and from your laptop at speeds of up to 5 Gbps via the USB-C and USB-A data ports. Note: The USB C 5Gbps Data port does not support video output.
- HD Display: Connect to the HDMI port to stream or mirror content to an external monitor in resolutions of up to 4K@30Hz. Note: The USB-C ports do not support video output.
- What You Get: Anker 332 USB-C Hub (5-in-1), welcome guide, our worry-free 18-month warranty, and friendly customer service.
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)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}`);The Free plan includes 1,000 screenshots per month with no card. Starter is $5 for 3,000, Growth $15 for 15,000, Pro $39 for 60,000, Scale $99 for 250,000, and Business $249 for 1,000,000; yearly billing gives two months free, and every feature is on every plan. Sign up for the free plan to capture full pages without installing or maintaining a browser.
FAQ
Can Rust capture a full page without launching a browser?
Not reliably for modern, JavaScript-heavy sites. A browser engine is needed to execute scripts, apply CSS layout, load fonts, and resolve responsive behavior. A remote screenshot API is the alternative when you do not want to manage that browser.
Does full-page mode automatically include content below an infinite scroll?
No. Infinite-scroll applications may not have that content in the DOM until you scroll or activate their loading control. Your program must define how far to load before capture.
Which crate should a new project choose?
Choose Playwright bindings for a page-oriented automation model and a direct full-page option. Choose headless_chrome when direct CDP access fits an existing Chrome automation architecture.
Can I take a PDF instead of an image?
Browser libraries and ScreenshotNeo can produce PDFs, but PDF pagination and print CSS are different from one very tall image. Select paper size, margins, orientation, and page ranges when your output is intended for printing or document delivery.
Frequently Asked Questions
Can Rust capture a full page without launching a browser?
Not reliably for modern, JavaScript-heavy sites; use browser automation or a remote screenshot service.
Does full-page mode include infinite-scroll content automatically?
No. Scroll or trigger the application’s loading control before capture.
The Tool Desk
Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Which Rust crate is better for a new project?
Use Playwright bindings for a high-level page model; use headless_chrome when direct CDP control is the better fit.
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.
