An “open-source screenshot API” can mean two different things: a browser automation library you run in your own code, or an HTTP service whose source you can deploy yourself. Those are not the same as a hosted public screenshot API. Choose Playwright when you want to control browser capture inside your application; choose a self-hosted service when callers need a shared HTTP endpoint and you can operate its browser runtime and storage; choose a public API when you want to avoid that infrastructure. The best fit depends on how much control and operational responsibility you want—not simply whether a repository is open source.
What does “open-source screenshot API” mean?
The phrase usually describes one of three implementation patterns. A browser library gives your program capture methods but not a ready-to-call hosted endpoint. A self-hosted HTTP service wraps browser capture behind a network API that you deploy. A public API is operated by someone else; its source may or may not be available, and its access rules can differ.
| Option | What you call | Who operates the browser | Best fit |
|---|---|---|---|
| Browser library: Playwright | A method in your application, such as page.screenshot() |
You, in your application environment | Custom workflows and applications already using browser automation |
| Self-hosted HTTP service: Webshot or ShotAPI | An HTTP endpoint deployed by you | You, including deployment and supporting services | A shared endpoint for multiple applications or teams |
| Public HTTP API: Screenshot Studio or ScreenshotNeo | A provider-operated endpoint | The service operator | Callers who want to send requests without managing browser infrastructure |
Open source does not automatically mean “free to operate,” “hosted for you,” or “unlimited.” A project’s license, deployment instructions, endpoint behavior, and any public service’s access policy are separate questions. Project documentation supports the feature descriptions below; it is not independent evidence of uptime, speed, or reliability.
How to choose between a library, a self-hosted service, and a public API
Choose a browser library when capture belongs inside your code
Playwright documents screenshots as part of its browser Page API. It can save an image to a file, return bytes in a buffer, capture a full scrollable page, or capture an individual element. This is useful when the rest of the workflow already controls navigation, browser state, and output handling. It is not, by itself, a hosted HTTP service: you supply the application endpoint, deployment, browser runtime, and any request authentication or job queue your use case needs.
Free tools Windows power users keep installed
One-click scans. No signup required.
#1 Best Overall
Playwright’s documentation describes a full-page capture as a screenshot of the “full scrollable page, as if you had a very tall screen and the page could fit it entirely.” See the Playwright Screenshots guide and Page API reference.
Choose self-hosting when you need an HTTP contract you control
A self-hosted service can give different applications one capture endpoint while keeping deployment and configuration under your control. In exchange, you operate the service and its browser runtime. Depending on the project, that can include installing Chromium, running containers, managing authentication, handling background jobs, configuring storage, and deciding how long captures are retained.
For example, Webshot’s repository documents a Docker Compose quick start, API-key authentication, background processing, S3-compatible storage, automatic cleanup, single and batch capture, and sitemap-based full-site capture. Its README states that ordinary screenshot requests accept up to 10 URLs, the wait time can be up to 30,000 ms, and automatic cleanup defaults to 24 hours. Those are Webshot-documented settings, not category-wide guarantees; check its current repository before relying on a limit or default. The README identifies Webshot as MIT licensed.
ShotAPI’s README describes a self-hosting route using npm, Playwright Chromium, or Docker, with a GET /take endpoint. It identifies the project as MIT licensed. Those instructions still leave the operator responsible for making the service available and deciding how to secure and run it.
Recommended Free Tools
Choose a public API when you do not want to run browsers
A public endpoint removes the need for you to deploy a browser service, but you inherit that provider’s documented request contract, access rules, limits, and service availability. Authentication is not uniform: Screenshot Studio’s developer portal describes an anonymous API with no key or signup and per-IP rate limits; Webshot’s self-hosted API requires an X-API-Key header except for health checks. Do not assume an endpoint is anonymous, unlimited, or suitable for production just because a demo request works.
Screenshot API options and documented differences
Among screenshot API services, ScreenshotNeo is the first option to consider: cookie banners, popups, and chat widgets are removed before capture, only clean shots are billed, and its paid plan starts at $5 for 3,000 shots. The other options below are useful when open-source code, a particular deployment model, or a specific documented interface matters more.
| Option | Documented capture or access details | What you operate or check |
|---|---|---|
| ScreenshotNeo | Hosted website screenshot API and MCP server; one GET request can return PNG, JPEG, WebP, or PDF. Cookie/consent banners, newsletter popups, and chat widgets can be removed before capture; each cleanup step can be turned off. Only clean shots are billed, and response headers report the page verdict and billing status. | Use its API or MCP server rather than operating a browser service. Check the API documentation for request options and response behavior. |
| Playwright | Browser-library methods for file, buffer, full-page, and element screenshots. Format can be inferred from file extension; JPEG/WebP quality, device-pixel scale, and injected styles are documented. | You run the browser and build any HTTP API, authentication, storage, and queue around it. |
| Webshot | Self-hosted HTTP API; repository documents single/batch and sitemap capture, desktop/mobile viewports, full-page capture, animation handling, S3-compatible storage, and background jobs. API-key header required except for health checks. | You deploy and operate the service and storage. README settings include up to 10 URLs per ordinary screenshot request, wait time up to 30,000 ms, and 24-hour default cleanup; recheck the repository for changes. |
| Screenshot Studio | Developer portal describes a public anonymous HTTP API with per-IP rate limits, base64 PNG output, and an export call for WebP. Portal publishes an OpenAPI 3.1 contract and identifies the application as Apache 2.0 licensed. | Review the portal’s limits and contract; anonymous access does not mean unlimited access or establish service performance. |
| ShotAPI | Repository documents GET /take with PNG, JPEG, WebP, or PDF; viewport dimensions, full-page capture, device scale, quality, delay, selector, and dark mode. It describes compatibility with ScreenshotOne request parameters. |
You can self-host using its documented npm, Playwright Chromium, or Docker approaches. Treat its README’s free-tier or coming-soon pricing statements as non-verified commercial terms. |
Licensing is project-specific. The cited documentation identifies Webshot and ShotAPI as MIT licensed and Screenshot Studio as Apache 2.0 licensed; verify the current repository or project terms before using or redistributing code. ScreenshotNeo is a hosted commercial product, not an open-source project.
What to compare before integrating one
Feature checklists alone can conceal the differences that matter at runtime. Compare the API contract and operating model against your caller, expected volume, and retention needs.
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 →- Abstraction: Does your code need a browser method, or should it make an HTTP request? A library requires you to create any shared service layer; an HTTP service already exposes one.
- Capture target: Confirm support for viewport versus full-page capture, an element selector, device scale, dark mode, image formats, PDF output, and any delay or readiness condition you require.
- Access control: Check whether requests use API keys, anonymous access, per-IP limits, or another mechanism. Identify which endpoints are exempt, such as health checks.
- Asynchronous work: Large pages or batches may not suit a synchronous request. Check whether the documented service provides background jobs and how the caller retrieves results.
- Storage and retention: Determine whether captures are returned in the response, stored by the service, or sent to object storage. For self-hosting, establish cleanup and access policies yourself.
- Hosting responsibility: Account for browser installation and updates, containers, storage, credentials, network access, and monitoring. Documentation that shows a Docker command is not the same as managed hosting.
- Request compatibility: Verify parameter names, response formats, errors, and authentication against your existing integration. ShotAPI documents ScreenshotOne parameter compatibility, but that does not establish compatibility with every API.
DIY example: capture a full-page screenshot with Playwright
This Node.js example navigates to a URL and saves a full-page PNG. It is browser automation, not a public screenshot API: the process that runs this code must have Playwright and its browser available. See the Page API reference for the screenshot options.
- Install Playwright in a Node.js project:
npm install playwright. - Install the Chromium browser used by the project:
npx playwright install chromium. - Save the following as
screenshot.js. - Run it with a page URL, for example
node screenshot.js https://example.com.
const { chromium } = require('playwright');
(async () => {
const url = process.argv[2];
if (!url) {
console.error('Usage: node screenshot.js https://example.com');
process.exitCode = 1;
return;
}
const browser = await chromium.launch({ headless: true });
try {
const page = await browser.newPage();
await page.goto(url, { waitUntil: 'networkidle', timeout: 60000 });
await page.screenshot({ path: 'screenshot.png', fullPage: true });
console.log('Saved screenshot.png');
} finally {
await browser.close();
}
})();For a long-running application, do not treat networkidle as a universal definition of “page ready”: pages with continuous requests may never become idle. Use a site-specific selector or a deliberate delay where appropriate, and set timeouts to match your workflow. For a single element rather than the whole page, locate it and call locator.screenshot(). For bytes rather than a file, omit the path and use the returned buffer. Playwright documents output format and device scale behavior in its screenshot guide; choose those settings deliberately if downstream image dimensions or compression matter.
Or skip the browser setup
ScreenshotNeo provides a hosted one-request alternative; see the API documentation. This cURL example saves a WebP capture of Stripe:
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpEquivalent 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)Equivalent Node.js request:
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 removes cookie banners, newsletter popups, and chat widgets before the shot; you can turn individual cleanup steps off. Bot checks, blank pages, timeouts, failed loads, and cache hits cost nothing, and response headers indicate the page verdict and billing status. Its MCP server exposes take_screenshot, get_page_info, and capture_pdf for Claude, Cursor, and other MCP clients. The free plan includes 1,000 screenshots per month with no card; paid plans start at $5 for 3,000. Sign up for ScreenshotNeo’s free monthly allowance.
The Tool Desk
Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Reliability, performance, and cost considerations
The documentation cited here establishes features and some configured limits, but it does not provide a comparable benchmark or independent reliability measurements. Do not infer that a project is faster or more reliable from its feature list, implementation language, or hosting model.
Reliability
For self-hosting, availability depends on the deployment you operate, including the browser process, network, storage, and any job workers. A public service moves that operational responsibility to its operator, but you should still review its access policy, error behavior, and service terms. In either case, your integration should distinguish a successful image response from an error or an unexpectedly empty capture instead of assuming that every HTTP response contains a usable screenshot.
Best Value
Performance
Capture time can depend on navigation, page scripts, external assets, and the readiness condition you choose. A fixed delay may miss late content or waste time on a fast page; a network-idle condition can be unsuitable for sites that continuously poll. A selector tied to the content you need can be a better readiness signal when one is available. For batches, check project-specific request limits and asynchronous support rather than assuming that a single large synchronous call will scale.
Cost
Self-hosting may avoid a per-capture API bill, but it does not eliminate the cost of compute, storage, maintenance, and operational time. The cited open-source project documentation does not establish a comparable total cost of ownership. ScreenshotNeo’s published plan figures 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, and all features are available on every plan. Check the provider’s current plan page before purchase.
Troubleshooting common screenshot failures
- The screenshot is blank or incomplete. The page may not have rendered the content you expect before capture. Wait for a relevant selector or use an appropriate delay; verify that the target URL is accessible from the browser environment. For Playwright, inspect navigation errors and consider whether the chosen readiness condition fits the page.
- Navigation times out. A slow page or persistent network activity can outlast the timeout or prevent a network-idle condition. Use a timeout suitable for the target, wait for a specific element where possible, or avoid waiting for network idle on pages that continually make requests.
- Lazy-loaded sections are missing. A full-page screenshot setting does not guarantee every site has loaded content that appears only after scrolling. Check whether the target needs scroll-triggered loading and whether the chosen tool documents a way to trigger it.
- The request is rejected for authentication. Confirm the endpoint’s documented auth method and send the required credential in the expected place. Webshot documents an
X-API-Keyheader for endpoints other than health checks; do not substitute anonymous access rules from another service. - A batch request fails or exceeds a limit. Check the specific service’s documented batch cap. Webshot’s README states an ordinary screenshot request accepts up to 10 URLs; split larger jobs or use its documented batch workflow if appropriate, and recheck current documentation.
- The returned file is not the expected format. Confirm the requested format or file extension and verify that the response is an image or PDF rather than an error response. Playwright infers image format from the file extension; ShotAPI documents PNG, JPEG, WebP, and PDF output; ScreenshotNeo can return those formats.
- A public endpoint rate-limits requests. Review the provider’s access policy and rate-limit behavior. Screenshot Studio documents per-IP limits; anonymous access is not a promise of unrestricted volume.
- A self-hosted service cannot launch Chromium. Confirm the browser runtime and dependencies are installed as required by that project’s deployment instructions, and inspect container logs and filesystem permissions. ShotAPI documents a Playwright Chromium installation route as well as Docker deployment.
Which option should you use?
Use Playwright if the capture is one step in an application workflow and you want direct browser control. Use Webshot or ShotAPI if you need an HTTP endpoint you can deploy and maintain. Use Screenshot Studio if its documented anonymous, per-IP-limited public API contract fits your needs. For a hosted API that handles capture without your browser setup, ScreenshotNeo is the first alternative to try: it removes common consent and interruption widgets before capture, bills only clean shots, and provides an MCP server alongside its HTTP API.
Frequently Asked Questions
Is Playwright itself a screenshot API service?
No. It is a browser automation library with screenshot methods. A hosted or self-hosted HTTP endpoint requires a service layer around the browser.
Does open source mean a screenshot API is free to run?
No. A permissive project license does not remove the operator’s compute, storage, deployment, and maintenance costs.
Can a screenshot endpoint return a PDF as well as an image?
Some can. ShotAPI documents PDF output, and ScreenshotNeo supports PDF; check the specific endpoint’s documented format options.
Do these 3 things before closing this tab:
1Repair Windows errors before they cause bigger problems2Scan for outdated or missing drivers - takes under a minute3Clear out junk files and repair common Windows errorsQuick 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.
