Screenshot API vs Browserless for Website Screenshots

For a managed screenshot API, Browserless documents a dedicated REST endpoint with controls for capture size, format, waiting, and request filtering. If you want clean captures with cookie banners, newsletter popups, and chat widgets removed—and billing that excludes failed or unclean captures—try ScreenshotNeo first. These products serve overlapping needs, but the available documentation does not establish which is faster, more reliable, or produces more faithful images. This comparison is based on documentation, not a hands-on benchmark.

1. Quick comparison

Question	Browserless	ScreenshotNeo
What is it?	A managed browser API platform with a dedicated screenshot REST endpoint.	A website screenshot API and MCP server for developers.
How do you capture?	Documented POST /screenshot request with a token, URL or inline HTML, and capture options.	One GET request to the shot API with a URL and access key; see the API documentation.
Workflow breadth	REST APIs also cover PDFs, rendered content, scraping, downloads, and function execution.	Screenshot-focused API and MCP tools for screenshots, page information, and PDF capture.
Clean captures and billing	The cited screenshot documentation discusses capture controls and request filtering. It does not establish the same consent cleanup or billing rules as ScreenshotNeo.	Accepts consent banners like a visitor and removes 60+ known consent platforms, newsletter popups, and chat widgets. Only clean shots are billed; response headers report the page verdict and billing state.
Pricing evidence	Current like-for-like pricing was not established by the sources used for this comparison.	Free: 1,000 shots/month without a card. Paid plans start at $5 for 3,000 shots; every feature is on every plan.

Choose based on the exact workflow and target pages you need. Browserless may fit a pipeline that also needs its other documented browser APIs. ScreenshotNeo may fit when clean captures, explicit billing outcomes, or MCP access matter. Neither statement is a measured performance claim.

2. What Browserless documents

Browserless documents a current REST screenshot endpoint at POST /screenshot. The request uses a token and can provide a URL or inline HTML. Its documented controls include full-page capture, viewport and selector capture, output format and quality, wait behavior, navigation settings, and request filtering. Consult the Browserless screenshot API documentation for the current request schema and accepted option values.

The screenshot endpoint is part of a broader REST API set that includes PDFs, rendered content, scraping, downloads, and function execution. That breadth can matter if your application already needs several managed browser tasks. See the Browserless REST API overview.

Browserless also documents an /unblock API designed to address bot detection mechanisms such as Datadome and passive CAPTCHAs. This describes the purpose of that API; it is not a guarantee that any particular site or challenge will be bypassed. The same caution applies to any automation against access controls: verify that your use is permitted and handle blocked pages explicitly.

Use the current REST docs for implementation. Browserless marks its older BaaS v1 screenshot documentation as deprecated and says that version is no longer actively supported.

3. What ScreenshotNeo adds

ScreenshotNeo returns PNG, JPEG, WebP, or PDF from a single API request. Its capture options include full-page screenshots with lazy images loaded, CSS selector element capture, dark mode, 12 device presets or a custom viewport, retina scale, PDF paper size, margins, landscape orientation and page ranges, HTML/CSS input, custom CSS and JavaScript, clicking an element before capture, hiding selectors, and waiting for a selector, delay, or network idle.

For control over page behavior and requests, it also supports blocking ads, trackers, requests, or resource types; custom headers, cookies, user agent, and Authorization; timezone and geolocation; transparent backgrounds; image resizing; a configurable cache TTL; signed links for public <img> tags; asynchronous jobs with signed webhooks; bulk capture of up to 100 URLs per call; a usage API; and an OpenAPI spec. The parameter names used by other screenshot APIs also work, which can ease migration.

Before capture, ScreenshotNeo accepts the cookie or consent banner like a visitor and removes more than 60 known consent platforms along with newsletter popups and chat widgets. Each step can be switched off. Bot checks or CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing; response headers identify the page verdict and whether the response was billed. Inspect the headers in your integration rather than assuming every HTTP response is a billable clean capture.

ScreenshotNeo also offers an MCP server for AI agents, including Claude, Cursor, and other MCP clients. Its tools are take_screenshot, get_page_info, and capture_pdf.

4. Compare the services for your workload

Capture controls

List the specific controls your screenshots need: full page or viewport, element selector, viewport dimensions, device scale, format, quality, and readiness waits. Browserless documents several of these controls. ScreenshotNeo documents these and additional options such as dark mode, lazy-image loading, selector hiding, and custom page interactions. Confirm parameter names and supported values in each service’s live documentation before porting a request.

Inputs and output types

Browserless documents URL or inline HTML input for its screenshot endpoint. ScreenshotNeo supports URL capture and HTML/CSS to image, plus PNG, JPEG, WebP, and PDF output. If you need a different output such as video, confirm it against the intended provider’s current docs; don’t infer it from a similarly named product.

Workflow breadth

If screenshots are one step in a process that also renders content, scrapes, downloads, or executes browser functions, Browserless’s broader REST API catalog may be relevant. If you need screenshot and PDF calls, batch captures, usage inspection, signed image links, or agent tools, ScreenshotNeo documents those features.

Pricing and volume

ScreenshotNeo lists Free with 1,000 shots a month and no card, Starter at $5 for 3,000, Growth at $15 for 15,000, Pro at $39 for 60,000, Scale at $99 for 250,000, and Business at $249 for 1,000,000. Yearly billing gives two months free, and every feature is on every plan. Check the current pricing page before purchase because prices and terms can change.

ScreenshotAPI.com is a separate vendor candidate surfaced during research, not Browserless. Its pricing page displays $0.001 per shot, but that page gives inconsistent free allowance quantities: one section says the first 100 shots are free and another says the first 1,000. Confirm the live offer before budgeting. A separate domain, ScreenshotAPI.net, has its own documentation; available evidence does not establish that it is the same product or company, so do not combine its feature claims with ScreenshotAPI.com pricing.

For a fair cost comparison, estimate your expected clean captures, retries, cache behavior, concurrency, and any feature-specific consumption from current plan pages. A per-shot figure alone may not capture how failed pages, cache hits, or non-screenshot API calls are treated.

Evidence limits

The available sources do not provide a like-for-like Browserless price comparison or controlled measurements of speed, uptime, block rate, image fidelity, or cost. Do not choose a supposed winner on those dimensions without current pricing checks or representative tests using the same URLs, settings, concurrency, and capture schedule.

5. A practical selection checklist

1. Write down the target pages and whether they require JavaScript, authentication, lazy-loaded images, or interaction.
2. Specify output needs: viewport or full page, element crop, image format, PDF, dimensions, and device scale.
3. Decide whether you need a broader browser API workflow or a screenshot-specific API and MCP tools.
4. Check how each service handles wait conditions, blocked resources, consent overlays, bot checks, timeouts, and cache hits.
5. Verify current plan limits, concurrency, timeouts, and how billing treats unsuccessful captures.
6. If visual accuracy or speed determines the choice, run a representative comparison and record the exact settings and results.

6. Browserless implementation notes

Browserless’s screenshot endpoint uses POST /screenshot and a token. Its documentation defines the available fields and output behavior; use that schema rather than guessing option names. The request shape below shows the documented endpoint and JSON approach. Replace the endpoint host and token with the values specified for your Browserless account, and confirm the payload fields against the current official endpoint reference.

cURL

curl -X POST "https://YOUR-BROWSERLESS-HOST/screenshot?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  --data '{"url":"https://example.com"}' \
  --output screenshot.png

Python

import requests

endpoint = "https://YOUR-BROWSERLESS-HOST/screenshot"
response = requests.post(
    endpoint,
    params={"token": "YOUR_TOKEN"},
    json={"url": "https://example.com"},
    timeout=90,
)
response.raise_for_status()
with open("screenshot.png", "wb") as image:
    image.write(response.content)

Node.js

const endpoint = new URL("https://YOUR-BROWSERLESS-HOST/screenshot");
endpoint.searchParams.set("token", "YOUR_TOKEN");

const response = await fetch(endpoint, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ url: "https://example.com" }),
});

if (!response.ok) {
  throw new Error(`Screenshot request failed: ${response.status} ${await response.text()}`);
}

const bytes = new Uint8Array(await response.arrayBuffer());
await Bun.write("screenshot.png", bytes);

These minimal examples request the default capture behavior. Add full-page, selector, format, wait, or filtering options only with the exact field names and values in the current Browserless docs. For Node.js runtimes without Bun.write, write the response bytes with the runtime’s filesystem API.

7. Or skip the browser setup

ScreenshotNeo takes a screenshot with one GET request. See the ScreenshotNeo API docs for options and response headers.

cURL

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webp

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 request failed: ${res.status}`);
const bytes = new Uint8Array(await res.arrayBuffer());
await import('node:fs/promises').then(fs => fs.writeFile('shot.webp', bytes));

• Cookie banners, newsletter 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.
• 1,000 screenshots a month are free with no card; paid plans start at $5 for 3,000.

Sign up free for 1,000 screenshots a month, with no card required.

8. Reliability, performance, and cost in production

Readiness and page behavior

A page load event does not necessarily mean that all client-rendered content or lazy images are ready. Use the provider’s supported wait conditions, selector waits, or deliberate delays when required. If a page depends on interaction, confirm whether the service can perform it before capture; ScreenshotNeo documents click-before-capture and custom JavaScript. Avoid waiting for network idle blindly on pages with long-lived connections, where that condition may never arrive.

Timeouts and retries

Set client timeouts long enough for navigation and rendering, but bound them so stalled jobs do not consume worker capacity indefinitely. Retry transient network errors with a small, capped backoff. Do not retry invalid requests or known blocked pages unchanged. Capture and log status, response headers, page verdict, and the target URL so that a failure can be distinguished from an image parsing issue.

Resource filtering and visual completeness

Blocking ads, trackers, or heavy resources can reduce work, but a broad block rule may also remove fonts, stylesheets, scripts, or images required for the page to look correct. Start with narrow rules and compare the result against an unfiltered capture. Authenticated pages may need cookies, headers, or an authorization value; protect those credentials and avoid logging them.

Cache and concurrency

For repeated URLs, choose a cache TTL based on how quickly the page changes and how stale a screenshot can be. ScreenshotNeo lets you choose the TTL and says cache hits are not billed. For a large batch, use its bulk endpoint for up to 100 URLs per call, or async jobs with signed webhooks where waiting synchronously is inconvenient. Keep concurrency within the current service limits and your own downstream capacity.

Cost control

Estimate monthly capture volume and separate successful clean images from retries, cache hits, and failed or blocked pages. ScreenshotNeo’s response headers report verdict and billing state, which can make usage reconciliation clearer. For any service, check the live plan and billing terms before scaling; the Browserless pricing comparison was not established by the sources used here.

9. Troubleshooting

Symptom	Likely cause	What to check or change
Authentication or authorization error	Missing, invalid, or misplaced token or access key.	Check the provider’s current authentication format, account key, and endpoint host. Keep credentials out of source control and logs.
Request rejected or unexpected output	Payload field, option value, or content type does not match the endpoint schema.	Use the current API reference; send JSON with the documented content type and verify each option is supported by that endpoint version.
Screenshot is blank or incomplete	Capture ran before client rendering or images finished, a selector was wrong, or required resources were blocked.	Wait for a visible selector or appropriate readiness condition, check the URL and selector, and remove broad resource filters.
Lazy images are missing	Images load only after scrolling or a page-specific trigger.	Enable the service’s documented full-page/lazy-image behavior where available, or use supported interaction and wait options.
CAPTCHA, bot check, 403, or access denied	The destination is refusing automated access or requires a permitted authenticated session.	Confirm authorization and target-site terms. Do not treat a bot-handling feature as a guarantee; capture and classify the blocked response rather than retrying endlessly.
Request times out	Slow navigation, an unbounded wait condition, or stalled target resources.	Set a bounded client timeout, use a more specific wait, and cap retries with backoff.
Image file cannot be opened	The response may contain JSON or an error page rather than image bytes.	Check HTTP status and response headers before saving; inspect the error body without treating it as an image.
Unexpectedly different images	Different viewport, scale, timezone, geolocation, cookies, browser state, or dynamic page content.	Fix capture settings and input state for repeated runs. Compare screenshots only with matching options and acknowledge that dynamic content may still vary.
Unexpected charge or usage count	Plan rules, retries, or treatment of cache and unsuccessful jobs differ by provider.	Read current billing terms. For ScreenshotNeo, inspect X-Page-Verdict and X-Billed response headers and the usage API.

10. FAQ

Is this a measured head-to-head test?

No. It is a documentation-based comparison. No speed, uptime, image-fidelity, or block-rate benchmark was conducted.

Are ScreenshotAPI.com and ScreenshotAPI.net the same service?

The available research does not establish that. Treat the pricing page and documentation as separate sources unless the vendors confirm the relationship.

Can I use Browserless v1 screenshot examples?

Prefer the current REST screenshot endpoint docs. Browserless labels its BaaS v1 screenshot docs deprecated and says that version is no longer actively supported.

Which should I try first?

Try ScreenshotNeo first if clean screenshots, billing only for clean captures, a low-cost paid entry plan, or MCP access match your needs. Choose after checking current requirements and testing representative pages when fidelity or throughput is decisive.