Puppeteer Screenshot API Pricing Compared with Hosted Services

Puppeteer has no per-screenshot plan price: it is a JavaScript browser automation library, and when you run it locally, you supply and operate the browser and runtime. Hosted screenshot services charge for managed rendering under their own quotas and billing rules. In the pricing snapshot reviewed for this article, ScreenshotOne lists 100 free screenshots per month and a $17 monthly Basic plan for 2,000; Urlbox lists a $19 monthly Lo-Fi plan for up to 2,000 renders. Those sticker prices do not establish which option costs less for your workload.

To compare fairly, estimate eligible successful outputs, account for cache and failure billing, and include self-hosting compute, storage, retries, monitoring, and maintenance. Prices and plan details change, so verify the live provider pages before choosing.

1. What you are comparing

Option	What you pay for	What you operate
Puppeteer run by your team	No per-render Puppeteer plan price is published in the cited official documentation.	Browser installation or remote browser access, runtime, scaling, capture code, output storage and delivery, retries, monitoring, and maintenance.
Hosted screenshot API	A provider’s monthly quota, usage charges, or both, according to its billing rules.	Your integration, request scheduling, response handling, and any application-specific storage or delivery.

Puppeteer provides browser-control APIs such as Page.screenshot() for a page and ElementHandle.screenshot() for a selected element. The library is not itself a hosted rendering endpoint. Its documentation distinguishes the full puppeteer package, which downloads Chrome for Testing and a headless shell, from puppeteer-core, which does not download Chrome and is intended for cases where you manage the browser or connect remotely. See the Puppeteer overview, screenshot guide, and installation guide.

2. Hosted pricing snapshot

The following USD monthly list prices and quota rules come from the providers’ official pages reviewed for this comparison. Prices exclude VAT where the provider says so. Features, quotas, request limits, and billing rules can change.

Service	Published plan snapshot	Billing and limits to check
ScreenshotNeo	Free: 1,000 shots/month. Starter: $5 for 3,000; Growth: $15 for 15,000; Pro: $39 for 60,000; Scale: $99 for 250,000; Business: $249 for 1,000,000. Yearly billing gives two months free.	Only clean shots are billed; bot checks/CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing. Every feature is on every plan. See the documentation.
ScreenshotOne	100 screenshots/month free. Basic: $17/month for 2,000; Growth: $79/month for 10,000; Scale: $259/month for 50,000. Listed overages are $0.009, $0.006, and $0.004 per screenshot, respectively.	Only successful renders not served from cache count against quota, according to its pricing page. Listed request limits are 40, 80, and 150 requests per minute by tier; feature availability differs. Its page says annual billing includes two months free.
Urlbox	Lo-Fi: $19/month for up to 2,000; Hi-Fi: $49/month for up to 5,000; Ultra: $99/month for up to 15,000; Business: $498/month with a stated base-plus-usage structure.	Tier limits differ for request rate, timeouts, and third-party-site support. Unsuccessful renders are not charged. Render Links screenshots are cached for 30 days and cached Render Links do not count against quota; first-time/API renders do.
Browserless	No comparable numeric plan figure is quoted here: the official pricing result reviewed did not provide enough stable price and quota detail to verify a comparable unit.	Its screenshot endpoint accepts a URL or HTML, Puppeteer-style settings, full-page mode, and PNG, JPEG, or WebP output. Check its live pricing page for current units and plans.

Sources: ScreenshotOne pricing, ScreenshotOne plan and billing information, Urlbox pricing, Browserless screenshot API, Browserless REST APIs, and Browserless pricing. ScreenshotNeo pricing and billing details are provided on its site and documentation.

3. How to estimate your real monthly cost

1. Count expected outputs. Estimate screenshots you need delivered in a month, not just requests your application sends. Include scheduled pages, retries, and likely recaptures.
2. Define a billable output. Record whether each provider charges for successful results, failed loads, retries, or cache hits. A response can be technically successful but visually unusable, so also decide how you will detect blank or incomplete pages.
3. Apply the plan’s quota and overage. For a hosted provider, calculate the plan covering your eligible volume, then add published overage or usage charges where applicable. Check whether free allowance, annual billing, or tier features change the estimate.
4. Include request-rate and timeout constraints. A monthly quota is not enough if a batch must finish quickly. Check requests per minute, concurrency rules, and maximum render time for the specific plan.
5. Build a self-hosting cost model. Include browser and runtime compute, browser downloads and updates, output storage and transfer, concurrency headroom, queueing, retries, observability, and engineering time spent maintaining the system.
6. Compare required features. Note full-page and element capture, output formats, PDF, custom browser settings, caching, integrations, and any other workflow requirement. A cheaper plan that lacks a needed feature is not a comparable option.

At exactly 2,000 eligible, uncached successful outputs per month, the listed entry paid-plan prices are $17 for ScreenshotOne Basic and $19 for Urlbox Lo-Fi. That is a narrow plan-price comparison: the quotas, rate limits, features, and counting rules differ. ScreenshotNeo’s listed Starter plan is $5 for 3,000 shots, and its stated billing rules exclude failed or unclean captures and cache hits. These figures are vendor-published prices, not a standardized benchmark.

There is no source-backed full monthly cost for running Puppeteer yourself, or a universal break-even volume. Estimate that from your own browser workload, infrastructure prices, staffing assumptions, and reliability requirements instead of assuming self-hosting is automatically cheaper.

4. Running Puppeteer for screenshots

This minimal Node.js example uses Puppeteer’s bundled browser, visits a page, waits for the page load event, captures a full-page PNG, and closes the browser even if capture fails. Install the package and run the script with Node.js:

npm install puppeteer

// screenshot.mjs
import puppeteer from 'puppeteer';

const target = process.argv[2] ?? 'https://example.com';
const browser = await puppeteer.launch({ headless: true });

try {
  const page = await browser.newPage();
  await page.setViewport({ width: 1440, height: 1000, deviceScaleFactor: 1 });
  await page.goto(target, { waitUntil: 'networkidle2', timeout: 30_000 });
  await page.screenshot({ path: 'shot.png', fullPage: true });
  console.log('Saved shot.png');
} finally {
  await browser.close();
}

node screenshot.mjs https://example.com

networkidle2 is a useful starting point, not a guarantee that every site is visually ready. Some pages keep connections open or load content after network activity settles. For those pages, use a targeted selector wait or a deliberate delay rather than increasing the timeout without diagnosing the page.

Capture one element instead of the whole page

const card = await page.waitForSelector('.pricing-card', { timeout: 10_000 });
if (!card) throw new Error('Pricing card was not found');
await card.screenshot({ path: 'pricing-card.png' });

Element capture is useful when a page is long or only one component matters. The selector must match the rendered DOM, and the element must be visible and have a non-zero size. See the official screenshot guide for page and element screenshot behavior and options.

Installation and browser management

Installing puppeteer downloads a recent Chrome for Testing and a chrome-headless-shell binary. The documentation’s approximate Chrome download sizes for Puppeteer version 25.12.0 were 170 MB on macOS, 282 MB on Linux, and 280 MB on Windows; these are download sizes, not a production cost estimate, and version details change. Choose puppeteer-core if you manage the browser yourself or use a remote browser, and explicitly configure the executable or connection. Keep the Puppeteer and browser versions compatible.

5. Hosted screenshot API options

Hosted services can remove the need to provision and manage a local browser, but compare their actual interface, plan limits, billing definitions, and output requirements. The sources reviewed document materially different APIs and plan rules.

• ScreenshotNeo: one GET request returns PNG, JPEG, WebP, or PDF. It includes consent-banner acceptance/removal, newsletter-popup and chat-widget removal, billing headers that identify the page verdict and billing status, and an MCP server with screenshot, page-info, and PDF tools. Plans list 1,000 free shots monthly and Starter at $5 for 3,000; see the product’s API documentation.
• ScreenshotOne: review the provider’s pricing and feature table for tier availability, successful-render and cache treatment, rate limits, and overages.
• Urlbox: review its pricing page for quota, timeout, rate, third-party support, and Render Links cache details.
• Browserless: its screenshot endpoint documentation describes URL or HTML input, screenshot settings, full-page capture, and image formats. Check its current pricing page directly before estimating cost.

6. Or skip the browser setup

If you would rather call a managed screenshot API, ScreenshotNeo is the first alternative to try: it lists 1,000 free shots each month and its Starter plan is $5 for 3,000. A single GET request returns the image or PDF, and the API documentation covers the options.

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

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)

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);

• Cookie banners are accepted and removed before capture; newsletter popups and chat widgets are also removed. Each cleanup step can be turned off.
• Bot checks or CAPTCHAs, blank pages, timeouts, failed loads, and cache hits are never billed. Responses say which outcome occurred in the X-Page-Verdict and X-Billed headers.
• An MCP server lets AI agents, including Claude and Cursor, use screenshot, page-info, and PDF tools.
• 1,000 screenshots per month are free with no card; paid plans start at $5 for 3,000. Every feature is on every plan.

Create a free ScreenshotNeo account to get 1,000 screenshots a month with no card.

7. Performance, reliability, and cost tradeoffs

Self-hosted Puppeteer

• Performance: browser startup, page complexity, network conditions, image loading, viewport, and concurrency all affect capture time. Reusing browser processes can reduce repeated startup work, but requires careful isolation and lifecycle management.
• Reliability: handle navigation timeouts, browser crashes, blocked requests, pages that never become idle, and partial content. Use bounded retries with backoff, close pages and browsers in cleanup paths, and record the URL, wait condition, browser version, and failure stage.
• Cost: there is no Puppeteer per-render tariff in the cited docs. Model compute and storage at your chosen concurrency, plus the people time to keep browser images, dependencies, and capture behavior working.

Hosted rendering

• Performance: compare plan rate limits, concurrency, timeouts, and the provider’s supported capture features. Do not infer speed from monthly quota or price; the reviewed pages do not provide a common benchmark workload.
• Reliability: understand exactly which failure states are billable, whether cache responses count, and how you can distinguish errors from valid image responses. Add request timeouts and application-level handling for non-image/API error responses.
• Cost: calculate your eligible outputs against quota and overage rules. For cached workloads, verify cache behavior and retention; for variable workloads, account for peak bursts as well as monthly totals.

8. Common problems and fixes

Symptom	Likely cause	Fix
Puppeteer cannot launch Chrome	Browser binary is missing, incompatible, or unavailable in the runtime environment.	Use the puppeteer package to install its managed browser, or configure the executable/remote browser explicitly when using puppeteer-core. Check the official installation guide for platform setup.
Navigation timeout	The page is slow, waits on long-lived network requests, or never reaches the chosen idle condition.	Use a realistic timeout and a more appropriate wait condition such as domcontentloaded, then wait for the specific content selector. Avoid treating a larger timeout as a complete fix.
Screenshot is blank or incomplete	Capture ran before client-side rendering or lazy-loaded content finished.	Wait for a page-specific selector; for lazy content, scroll the page in controlled increments before capture and allow images to load. Confirm the expected content exists before saving.
Element screenshot fails	The selector matched nothing, the element is hidden, or it has no visible dimensions.	Wait for the selector, verify it is visible, and inspect its bounding box before calling screenshot().
Hosted response is not an image	The endpoint returned an authentication, quota, validation, or render error.	Check HTTP status and response headers before saving bytes as an image. For ScreenshotNeo, inspect X-Page-Verdict and X-Billed; consult the provider documentation for its error format.
Monthly spend is higher than request count suggests	Providers may count successful uncached outputs, first-time links, retries, or usage above quota differently.	Reconcile provider usage against outcomes and cache status. Model billable outputs rather than raw request volume and read current plan terms.

9. Frequently asked questions

Is Puppeteer itself a screenshot API?

No. It is a browser automation library with screenshot methods. You can build an API around it, but you must also run or connect to a browser and operate the service.

Is self-hosting always cheaper?

There is no source-backed universal break-even point. It depends on your browser compute, storage, volume, operational needs, and maintenance cost.

Which hosted plan is cheapest at 2,000 screenshots?

In the reviewed list prices, ScreenshotNeo Starter is $5 for 3,000 shots, ScreenshotOne Basic is $17 for 2,000, and Urlbox Lo-Fi is $19 for up to 2,000. Billing definitions and features differ, so compare the output you need and current live terms.

Can Puppeteer capture just part of a page?

Yes. Select an element and call its screenshot() method; the selector must resolve to a visible element.

Do these prices include taxes?

Provider pages may exclude VAT or apply taxes based on location. Check the current checkout or pricing terms for your billing region.