What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Use Playwright when you need browser-level control, or call a hosted website screenshot API when you want an HTTP response without maintaining Chromium. Playwright can save a viewport or full-page capture as JPEG, with quality from 0 to 100 (80 by default). JPEG is opaque, so use PNG when you need transparency. Hosted APIs can add render delays, caching, authentication and operational convenience.
Choose the capture approach
Your choice is mainly operational rather than visual: both approaches can produce a JPEG, but they place responsibility in different parts of your stack.
| Approach | Best fit | What you control | What you operate |
|---|---|---|---|
| Playwright | Automated tests, internal jobs and workflows needing browser control | Chromium version, viewport, waits, headers, cookies, scripts and capture logic | Browser binaries, memory, concurrency, retries and security updates |
| Hosted screenshot API | Applications that need an HTTP image response without running a browser | Request parameters exposed by the provider, such as format, delay and cache settings | Usually the API request, authentication, response storage and your retry policy |
There is no published cross-provider performance or price benchmark in the technical documentation considered here. Test your own pages, traffic and retention requirements before selecting a service.
Take a website screenshot as JPEG with Playwright
Playwright supports PNG, JPEG and WebP. In Node.js, install the package and its browser binaries, then run a script such as this:
Do these 3 things before closing this tab:
1Repair Windows errors before they cause bigger problems2Fix the driver behind crashes, sound loss and screen glitches3Clear out junk files and repair common Windows errors#1 Best Overall
import { chromium } from 'playwright';
const browser = await chromium.launch();
const page = await browser.newPage({
viewport: { width: 1440, height: 900 }
});
await page.goto('https://example.com', { waitUntil: 'networkidle' });
await page.screenshot({
path: 'example.jpeg',
type: 'jpeg',
quality: 80,
fullPage: true
});
await browser.close();The explicit type: 'jpeg' is unambiguous. Playwright can also infer the format from a filename ending in .jpeg. The documented JPEG quality range is 0–100; the default is 80. A higher value preserves more detail but normally creates a larger file, while a lower value reduces size at the cost of compression artifacts.
Install and run
- Install Node.js supported by your application.
- Install Playwright with
npm install playwright. - Install the browser binaries with
npx playwright install chromium. - Save the script as an ES module (for example,
screenshot.mjs) and runnode screenshot.mjs. - Confirm that
example.jpegis written in the process’s working directory.
In a container or CI runner, include the browser installation step in the image or build job. Running as a non-root user and granting only the permissions Chromium needs reduces the impact of an untrusted target URL.
Viewport versus full-page capture
A normal screenshot captures the current viewport. Set fullPage: true to capture the page’s scrollable document from top to bottom. Full-page images can become extremely tall; check the dimensions and downstream storage limits before enabling this for arbitrary URLs.
Controlling visual stability
Use a fixed viewport when comparing captures. waitUntil: 'networkidle' waits for network activity to settle, but it is not a universal guarantee that every font, animation or client-side component has reached the state you want. For dynamic pages, add an application-specific wait for a selector, a deliberate delay, or both. Disable animations with injected CSS when a moving carousel or transition would make captures inconsistent.
JPEG limitations
JPEG has no alpha channel. Playwright’s transparent-background option is therefore not applicable to JPEG output. Choose PNG if the image must preserve transparent pixels, logos with alpha, or exact lossless text edges.
Rank #2
- HTML CSS Design and Build Web Sites
- Comes with secure packaging
- It can be a gift option
Playwright examples in Python
The synchronous Python API provides the same controls:
from playwright.sync_api import sync_playwright
with sync_playwright() as p:
browser = p.chromium.launch()
page = browser.new_page(viewport={"width": 1440, "height": 900})
page.goto("https://example.com", wait_until="networkidle")
page.screenshot(
path="example.jpeg",
type="jpeg",
quality=80,
full_page=True,
)
browser.close()Install the package with pip install playwright, then run playwright install chromium before executing the script. Use the asynchronous API when your service already uses an event loop or captures many pages concurrently; cap concurrency so browser memory does not exhaust the worker.
Use the Playwright CLI
For a one-off capture, the CLI can select JPEG with --type=jpeg and full-page mode with --full-page. A representative command is:
npx playwright screenshot --device="Desktop Chrome" --full-page --type=jpeg https://example.com example.jpegThe exact available device names and other flags depend on the installed Playwright version. Run npx playwright screenshot --help in that environment rather than copying flags from a different release.
Hosted website screenshot APIs
A hosted website screenshot API returns an image over HTTP and can be simpler for serverless functions, CMS integrations and scheduled jobs. ScreenshotAPI documents JPEG as a supported image format. ShotPilot documents GET https://shotpilot.dev/api/v1/screenshot; its format parameter accepts jpg or jpeg, the response uses image/jpeg, delay_ms adds time after network idle, and cache_ttl controls reuse for repeated requests.
Rank #3
Read each provider’s current parameter and authentication documentation before implementing. In particular, decide how the service handles redirects, failed navigation, bot checks, private pages, very tall documents and rate limits. Store the response as binary data, not as decoded text.
Operational checklist
- Set an explicit output format and quality where the API supports them.
- Set a viewport that matches the design you are evaluating.
- Add a post-load delay only when the page needs it; unnecessary delays increase latency.
- Use caching for immutable or slowly changing pages and choose a TTL that matches freshness requirements.
- Keep API keys in environment variables or a secret manager, never in client-side JavaScript.
- Record the target URL, requested options, response status, content type and elapsed time for troubleshooting.
Or skip the browser setup: ScreenshotNeo
ScreenshotNeo is a website screenshot API and MCP server. One GET request can return PNG, JPEG, WebP or PDF. It accepts cookie and consent banners as a visitor and removes more than 60 known consent platforms, newsletter popups and chat widgets before capture; each cleanup step can be disabled. Bot checks or CAPTCHAs, blank pages, timeouts, failed loads and cache hits are not billed, and the response reports the result in X-Page-Verdict and X-Billed headers.
Recommended Free Tools
Use the API documentation at https://screenshotneo.com/docs/ for the complete option list. Relevant controls include full-page capture with lazy images loaded, CSS-selector element capture, dark mode, 12 device presets or a custom viewport, retina scale, JPEG quality, PDF paper settings, custom CSS and JavaScript, pre-capture clicks, hidden selectors, waits for a selector, delay or network idle, request and resource blocking, headers, cookies, user agents, Authorization, timezone, geolocation, transparent backgrounds, resizing, a chosen cache TTL, signed image links, asynchronous jobs with signed webhooks, bulk capture of up to 100 URLs per call, a usage API and an OpenAPI specification. Parameter names used by other screenshot APIs also work to ease migration.
cURL:
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpTo request JPEG, add the JPEG format option documented for your account; the endpoint otherwise returns the format selected by your request or default.
Python:
import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"}, timeout=90)
r.raise_for_status()
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}`);
if (!res.ok) throw new Error(`Screenshot failed: ${res.status}`);
const fs = await import('node:fs/promises');
await fs.writeFile('shot.webp', Buffer.from(await res.arrayBuffer()));ScreenshotNeo’s MCP server exposes take_screenshot, get_page_info and capture_pdf to Claude, Cursor and other MCP clients, so an AI agent can request captures without custom browser orchestration. Plans are Free with 1,000 shots per month and no card, Starter $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. Create a free ScreenshotNeo account to get the 1,000 monthly shots without a card.
Troubleshooting JPEG captures
The file is PNG or cannot be opened
Check that the requested format is JPEG and that your output filename matches. For an HTTP API, inspect the Content-Type header and save the body as bytes. A successful HTTP status alone does not prove that the body is an image.
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Scan for outdated or missing drivers - takes under a minuteDriver Scan →Rank #4
- Brand: Wiley
- Set of 2 Volumes
- A handy two-book set that uniquely combines related technologies Highly visual format and accessible language makes these books highly effective learning tools Perfect for beginning web designers and front-end developers
The page is cut off
Viewport mode intentionally captures only the visible area. Enable fullPage (or --full-page) for the entire scrollable document. If the result is still incomplete, the site may load content only after scrolling; wait for the relevant selector or use a provider’s lazy-image/full-page handling.
Fonts, images or widgets are missing
Wait for the page state your application needs rather than relying only on the initial navigation event. Check that the worker can reach the asset domains, that request blocking is not too broad, and that the target does not require authentication or a consent interaction.
The capture is inconsistent
Fix the viewport, browser version and timezone, wait for a stable selector, and disable animations where possible. Network-idle is a useful signal, not a guarantee for pages with polling, ads or long-lived connections.
JPEG looks blocky
Increase quality toward 100 or use PNG for lossless output. If storage or bandwidth is the constraint, lower quality gradually and inspect text and fine lines at the final display size.
Outdated 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 matchPC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Requests time out or are rejected
Verify the URL, DNS and outbound network policy, then increase the operation timeout within the provider’s limits. Treat bot checks, CAPTCHAs, blank responses and repeated navigation failures as target-site conditions; do not retry indefinitely. Log the provider’s status and verdict headers when available.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Performance, reliability and cost decisions
Control concurrency
Each Playwright browser and page consumes CPU and memory. Reuse a browser process where safe, limit simultaneous pages, and close pages in a finally block. Hosted APIs shift browser capacity to the provider, but you still need client-side timeouts, bounded retries and backoff.
Cache deliberately
Caching is valuable for documentation, catalog and monitoring pages that do not change every request. Use a TTL that reflects how quickly the source changes. Do not cache authenticated or personalized captures under a shared key unless the provider explicitly isolates those responses.
Protect sensitive targets
Never accept arbitrary user-supplied URLs without validation: screenshots can be used to probe internal services or exfiltrate pages reachable from your network. Restrict schemes, block private address ranges, avoid logging secrets in query strings and keep cookies and Authorization headers scoped to the intended domain.
Free tools Windows power users keep installed
One-click scans. No signup required.
Plan for image handling
Full-page JPEG dimensions and file sizes vary with document length, viewport and quality. Enforce maximum dimensions or byte sizes before storing or forwarding results. Preserve the original response when auditability matters, and generate resized derivatives for thumbnails.
Which method should you use?
- Choose Playwright when you need to control the browser runtime, execute custom code locally, integrate deeply with an existing test suite or keep all rendering inside your infrastructure.
- Choose a hosted API when an HTTP request, provider-managed browsers, delay controls and caching are more important than maintaining Chromium.
- Choose ScreenshotNeo first among hosted options when clean captures, no billing for failed or blocked pages, MCP access for AI agents and a free 1,000-shot tier address your workflow.
Frequently Asked Questions
Can a JPEG screenshot include a transparent background?
No. JPEG has no alpha channel; use PNG when transparent pixels must be preserved.
What quality should I use for website JPEGs?
Start at the documented default of 80, then raise or lower it after checking text, fine lines and file size at the intended display dimensions.
How do I capture only one element instead of the whole page?
With Playwright, locate the element and call its screenshot method; hosted services may expose an element CSS-selector option.
Is full-page capture the same as a browser viewport screenshot?
No. A viewport capture covers the visible window, while full-page mode renders the scrollable document.
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.
