Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Scan for outdated or missing drivers - takes under a minute3Repair Windows errors before they cause bigger problemsTo take a screenshot from a URL, load the page in a browser and save the rendered result: use browser controls for a one-off image, Playwright for a repeatable script, or Chrome Headless for a command-line capture. Choose a viewport, full-page image, or specific element according to what you need. If you would rather not set up a browser, ScreenshotNeo can return an image or PDF from one API request.
Choose the capture method and scope
A URL is an address, not an image. The page has to load and render in a browser before it can be captured. For a one-time screenshot, open the page in your browser and use its screenshot controls. For repeated captures or a scriptable workflow, use Playwright. For a direct command-line capture, Chrome Headless documents a --screenshot flag.
| Need | Suitable method | What to decide |
|---|---|---|
| One-off capture | Browser screenshot controls | Whether the visible screen is enough or the page needs to be captured beyond the viewport. |
| Repeatable capture in a script | Playwright | Viewport, full page, or a particular element; choose the screenshot options supported by your installed version. |
| Simple command-line capture | Chrome Headless | Window dimensions and whether a viewport image meets the need. |
| Capture without managing a local browser | ScreenshotNeo API | Use its documented parameters and review the response headers to distinguish capture outcomes and billing. |
For the first two documented automation paths, Playwright is a browser automation API suited to scripts, while Chrome Headless offers a command-line option. The capture scope is a separate choice: the current viewport, the full scrollable page, or a specific element. Playwright documents all three. Its screenshots documentation lists PNG, JPEG, and WebP output types; check the documentation for your installed version for exact option names and behavior.
Take a screenshot with Playwright
Playwright’s basic sequence is to launch a browser, create a page, navigate to the target, save a screenshot, and close the browser. This Node.js example writes a viewport screenshot to screenshot.png:
#1 Best Overall
- Install Node.js if it is not already available in your environment.
- In a new project directory, install Playwright with
npm install playwright. - Save the following as
screenshot.mjs. - Run
node screenshot.mjs. The script should save the image in the current directory if navigation and capture succeed.
import { chromium } from 'playwright';
const url = process.argv[2] ?? 'https://example.com';
const browser = await chromium.launch();
try {
const page = await browser.newPage();
await page.goto(url);
await page.screenshot({ path: 'screenshot.png' });
console.log('Saved screenshot.png');
} finally {
await browser.close();
}Pass another page address as the first argument, for example node screenshot.mjs https://example.com. Replace the example address with a URL you are authorized to access. The example uses Playwright’s documented page.goto() and page.screenshot() flow. Consult the current Playwright Page API for navigation and screenshot options relevant to your site and installed version.
Choose the screenshot area
- Viewport: the screenshot call above captures the page’s visible browser viewport. It is appropriate when the image should show what fits on screen.
- Full page: use Playwright’s
fullPagescreenshot option when you need the page beyond the visible viewport. Confirm its behavior and other available options in the Page API documentation for your installed version. - One element: use Playwright’s element screenshot capability when the output should contain a particular component rather than the whole page. Select the element using the API supported by your version, then capture that element.
Playwright’s screenshots documentation covers viewport, element, and full-page captures, and lists PNG, JPEG, and WebP as supported output types. Match the output format and capture options to the next step in your workflow rather than assuming every format supports every option in every version.
When the first image is incomplete
A screenshot represents the rendered page at capture time. If the page has not finished rendering, the resulting image may not show the content you expected. For dynamic sites, decide what “ready” means for the page before adding waits or other automation: a visible element, a known delay, or another site-specific condition may be more useful than treating navigation alone as proof that every visual element is ready. Consult the current Playwright documentation for supported waiting and screenshot options; this assignment’s documented source establishes the navigation-and-capture flow, not a universal readiness rule.
For a long page, first verify that you actually need the full page rather than a viewport image. For a component capture, check that the selector identifies the intended element on the loaded page. These choices change what goes into the image, not the underlying URL.
Capture from a terminal with Chrome Headless
Chrome for Developers documents the --headless and --screenshot flags. Its example sets a window size of 412 by 892 pixels and saves screenshot.png in the current working directory. The following command adapts that documented pattern for an example URL:
chrome --headless --screenshot --window-size=412,892 https://example.comRun it in a terminal where the Chrome executable is available. The file is expected in the current working directory. If your executable is not named chrome, use the name or path appropriate to your installation. Verify that the installed Chrome version accepts the flags you use; command-line behavior can depend on the installed version.
The --window-size value controls the browser window dimensions used for this capture. Choose dimensions that fit the visible content you want. This example is a direct command-line route, not a Playwright script: use Playwright instead when your workflow needs browser automation or a specific element capture. The cited Chrome command-line documentation supports the screenshot flag and window-size example; it does not establish every other Chrome option or guarantee how a particular site will render.
Use ScreenshotNeo when you do not want to set up a browser
ScreenshotNeo is a website screenshot API and MCP server for developers. Its API accepts a URL in a GET request and returns a PNG, JPEG, WebP, or PDF. The service handles the browser capture for you, which can be useful for recurring jobs or integrations where installing and operating a browser is not the desired approach.
Install no browser for this example; provide an API key and target URL. See the ScreenshotNeo API documentation for parameters and response details.
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://example.com -o shot.webpReplace YOUR_API_KEY with your key and the example URL with the page to capture. The command saves the response body as shot.webp. Check the response headers: X-Page-Verdict and X-Billed indicate the page outcome and whether the request was billed. ScreenshotNeo says bot checks or CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing; only clean shots are billed.
For an image-cleanup workflow, ScreenshotNeo accepts cookie or consent banners as a visitor and removes more than 60 known consent platforms, newsletter popups, and chat widgets before capture. Each of those steps can be turned off. It also offers an MCP server for AI agents, including Claude, Cursor, and any MCP client, with take_screenshot, get_page_info, and capture_pdf tools. These are service features; they are not part of the local Playwright or Chrome examples above.
ScreenshotNeo’s stated plans are Free: 1,000 shots per month with 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. Every feature is on every plan. Review the service’s current site and documentation for details before choosing a plan.
PC 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 & 11Outdated 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 matchOr skip the browser setup: send one request with the URL and your key. Cookie banners, popups, and chat widgets are removed before the shot; bot checks, blank pages, and failed loads are never billed; an MCP server lets AI agents take screenshots; and 1,000 screenshots a month are free with no card, with paid plans starting at $5 for 3,000. Start with ScreenshotNeo’s free sign-up.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Troubleshoot common capture problems
- No image file appears: Check the terminal’s current working directory and confirm the command or script completed. Chrome’s documented example saves
screenshot.pngin the current directory; the Playwright example writes the named file where the Node.js process runs. - The output shows only part of a long page: A viewport capture is not the same as a full-page capture. With Playwright, use its full-page screenshot option and check the installed version’s API documentation.
- The wrong section appears: Confirm the target URL and, for an element capture, confirm that the selector identifies the intended component on that page.
- The page looks unfinished: Navigation and visual readiness are not necessarily the same for a dynamic page. Identify a page-specific ready condition and use the waiting features supported by your browser tool and version.
- Chrome rejects a flag: Verify the Chrome executable and installed version, then check whether that version accepts the command-line flags you supplied.
- An API request does not produce the expected capture: Check the URL, API key, response, and ScreenshotNeo headers. The
X-Page-VerdictandX-Billedheaders help identify the outcome and billing status; use the API documentation for request parameters and response handling.
Reliability, performance, and cost decisions
For occasional work, browser controls avoid writing a script. Playwright makes the navigation-and-save sequence repeatable, while Chrome Headless is a short terminal command. These local paths require a compatible browser environment; ScreenshotNeo is the hosted alternative when you would rather make an API call. Which is best depends on whether you value direct browser control, scripting flexibility, or outsourcing browser operation.
Best Value
For repeat captures, decide how to handle a slow or failed page, where output files should go, and what constitutes a usable image. A screenshot can be technically saved but still capture a blank, blocked, or incomplete page. Treat the image and, where available, the capture outcome as separate checks. Do not assume a successful file write proves the target rendered as intended.
Cost also depends on the route: the Playwright and Chrome documentation cited here does not specify a price for using those tools, while ScreenshotNeo publishes monthly allowances and plan prices above. For a large recurring job, estimate the number of requested captures and account for the service’s billing rules; the stated ScreenshotNeo rule is that only clean shots are billed, with cache hits and the listed failed outcomes costing nothing. Its cache settings, bulk capture, usage API, async jobs, and other options are described in its documentation.
Free tools Windows power users keep installed
One-click scans. No signup required.
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.
