Playwright screenshot API pricing: what affects the cost?

Playwright does not charge a per-screenshot fee: page.screenshot() is browser automation functionality. If you use a hosted service to run Playwright or capture pages through an API, that provider sets the price and billing rules. The bill may reflect browser runtime, concurrent sessions, screenshot requests, proxy traffic, plan allowances, and overages—not just the number of images.

To estimate cost, model a representative workload and apply the named provider’s current rates. Do not treat one vendor’s prices or credits as a general Playwright price.

1. What “Playwright screenshot API” means

There are two different things people may mean:

Playwright’s screenshot method: You run a browser with Playwright and call page.screenshot(). Playwright documents the method and its capture options; it does not publish a universal hosted API price. Your costs come from the machine, container, or cloud service where the browser runs.
A hosted browser or screenshot API: A provider runs the browser or accepts screenshot requests. Its plan defines what counts as billable usage, what is included, and what happens when you exceed an allowance.

Therefore, ask “what does this provider meter?” rather than “what does Playwright charge per screenshot?” The examples below are provider-specific published figures, not market averages. Pricing can change, so confirm the current pricing page before committing to a plan.

2. Cost dimensions that can change the bill

Dimension	How it can be billed	What to check
Browser runtime	Time the browser instance is running, sometimes in seconds or hours.	Whether startup, navigation, waiting, retries, and idle time count.
Concurrent sessions	A limit, included capacity, or charge for the number of browsers running at once.	Whether concurrency is averaged, peak-based, or separately metered.
Screenshot requests	A fixed unit per screenshot endpoint call, potentially in addition to runtime.	Whether failed requests, retries, or multiple images from one page count.
Proxy and network traffic	Traffic may be charged by data volume and proxy type.	Whether proxy use is optional, which resources are fetched, and whether traffic is counted separately.
Plan allowance and overage	A monthly or daily included amount followed by additional charges.	Reset timing, overage rate, concurrency allowance, and whether separate products have separate quotas.
Unused credits	Credits may expire at the end of a subscription period.	Whether balances roll over and how credits convert to money on the plan you would buy.
Capture settings and output	Settings can affect work performed and the image’s storage or transfer size; whether they affect the bill is provider-specific.	Ask whether full-page captures, high pixel scale, format, quality, or PDF output add metered work.

Browser runtime and concurrency

Runtime-based pricing means a slow destination or long wait can cost more than a fast capture, even when both produce one image. Concurrency affects throughput and may have its own allowance or price. For example, Cloudflare’s Browser Run pricing lists Quick Actions by browser hours. Its page lists 10 minutes of browser hours per day on Workers Free, and 10 hours per month on Workers Paid followed by $0.09 per additional hour. Browser Sessions are separately priced: the page lists three concurrent browsers on Workers Free, and 10 concurrent browsers averaged monthly on Workers Paid followed by $2.00 per additional browser. These are Cloudflare figures and plan terms, not Playwright rates. Cloudflare Browser Run pricing

Request units and proxy traffic

A provider can charge once for the browser’s running time and again for the screenshot endpoint or network usage. BrowserCloud lists one credit per second for a Playwright/Puppeteer browser instance, five credits per /screenshot request, 12 credits per MB for datacenter proxy traffic, and 110 credits per MB for residential proxy traffic. Its page says it disables downloads such as images, video, CSS, and fonts by default to optimize proxy usage, with an adjustable parameter. These rules describe BrowserCloud only. Credits are not directly comparable to dollars without the plan’s credit conversion and subscription price. BrowserCloud pricing

Capture configuration and image size

Playwright lets you configure screenshot format, quality, and scale, and can capture a full page. Its documentation notes that device scale can make images twice as large or more than CSS scale on high-DPI devices. Larger captures can increase processing, storage, and transfer needs, but the reviewed provider pricing examples do not establish a universal surcharge for any of these options. Check the service’s billing terms before assuming a setting changes—or does not change—the charge. Playwright screenshot API · Playwright screenshots guide

3. Estimate your monthly cost

Count the work. Estimate successful captures per month, average browser time per capture, peak simultaneous sessions, and expected retries.
Include network behavior. Estimate proxy traffic if the service meters it. Find out whether the provider blocks or fetches images, fonts, scripts, and other resources by default.
Apply each provider’s own units. Calculate runtime, request, concurrency, and traffic charges separately where applicable. Do not convert credits to money without the plan’s conversion rate.
Subtract only applicable allowances. Check whether browser hours and concurrency belong to separate products or quotas, when they reset, and whether unused credits expire.
Model slow and busy periods. Include long navigation times, timeouts, retries, bursts in parallel work, and month-end peaks. These affect runtime or capacity under plans that meter them.
Confirm image requirements. Test full-page versus viewport capture, output format, scale, and quality with representative pages. Ask the vendor whether those choices affect billing.
Recheck before purchase. Vendor rates and plan terms are volatile. Use the provider’s current pricing page and terms, not an old estimate.

A useful comparison worksheet has one row per provider and columns for browser time, request units, concurrency, proxy traffic, included allowances, overages, credit expiry, and capture settings. Compare the totals only after applying each provider’s own unit conversion and limits.

4. Run a local Playwright screenshot

When you run the browser yourself, there is no hosted screenshot API bill from Playwright. You still pay for the compute and storage you choose, and must operate the browser environment. This minimal Node.js example captures one page to a PNG file.

import { chromium } from 'playwright';

const browser = await chromium.launch({ headless: true });
try {
  const page = await browser.newPage({ viewport: { width: 1440, height: 900 } });
  await page.goto('https://example.com', { waitUntil: 'networkidle', timeout: 30_000 });
  await page.screenshot({ path: 'shot.png', fullPage: true });
} finally {
  await browser.close();
}

Install Playwright and its browser binaries using the official Playwright installation guide. The example uses networkidle to wait for network activity to settle; pages with persistent requests may never reach that state. If that happens, wait for a meaningful selector or use a bounded delay instead. fullPage: true captures the full scrollable page. Screenshot type, quality, scale, clip, omitBackground, and animation behavior are documented in the API reference; quality applies to JPEG, while PNG is the default format.

Equivalent cost questions for cURL, Python, and Node.js clients

These examples show a hosted provider’s API call shape, not a Playwright price. The endpoints and auth formats are illustrative placeholders; use the endpoint, credential method, and parameters documented by the provider you choose. The cost still depends on that provider’s meter.

cURL:

curl -X POST 'https://YOUR_PROVIDER.example/v1/screenshot' \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"url":"https://example.com"}' \
  --output shot.png

Python:

import requests

response = requests.post(
    'https://YOUR_PROVIDER.example/v1/screenshot',
    headers={'Authorization': 'Bearer YOUR_API_KEY'},
    json={'url': 'https://example.com'},
    timeout=90,
)
response.raise_for_status()
with open('shot.png', 'wb') as image:
    image.write(response.content)

Node.js:

const response = await fetch('https://YOUR_PROVIDER.example/v1/screenshot', {
  method: 'POST',
  headers: {
    Authorization: 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ url: 'https://example.com' }),
  signal: AbortSignal.timeout(90_000),
});
if (!response.ok) throw new Error(`Screenshot request failed: ${response.status}`);
await Bun.write('shot.png', response); // Or consume response.arrayBuffer() in Node.

Replace every placeholder with the chosen vendor’s actual API contract. A request count alone is not a valid estimate when that provider also meters runtime, concurrency, or traffic.

5. Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server from ScreenshotNeo. One GET request returns PNG, JPEG, WebP, or PDF output. See the ScreenshotNeo API docs for its request options.

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

Cookie and consent banners are accepted like a visitor and removed before the shot, along with supported newsletter popups and chat widgets. Each cleanup step can be turned off. Bot checks, blank pages, timeouts, failed loads, and cache hits cost nothing; response headers say which page verdict applied and whether the request was billed. The MCP server gives AI agents tools for screenshots, page information, and PDF capture. The free plan includes 1,000 shots a month with no card; paid plans start at $5 for 3,000 shots. Sign up for 1,000 free screenshots a month, with no card.

6. Performance, reliability, and cost controls

Measure elapsed browser time. If a provider meters runtime, slow navigation, excessive waiting, and retries can raise the effective cost per successful image. Record a representative sample rather than assuming every page takes the same time.
Choose waits for the page. Waiting for all network activity can be unreliable on pages with analytics, streaming, or polling. Prefer a page-specific readiness selector where possible, with a timeout and an explicit fallback.
Set concurrency to real demand. More parallel sessions can improve throughput but may exceed included capacity or cause throttling. Check the provider’s concurrency definition and test the burst pattern you expect.
Bound retries and timeouts. Retries help with transient navigation failures, but they can consume runtime or request units. Use a small retry limit and track failed attempts.
Match output to use. A smaller viewport or suitable image format can reduce file size and transfer time. Do not assume this reduces a provider’s bill unless its pricing rules say so.
Track usage units separately. Log request count, successful captures, elapsed time, retries, concurrency, and proxy/data usage. Compare these with provider invoices or usage dashboards.
Check allowance boundaries. Daily limits, monthly allowances, concurrency ceilings, and expiring credits can make a nominally low plan expensive for spiky workloads or unused balances.

7. Troubleshooting unexpected costs

Symptom	Likely cause	What to do
The invoice is higher than screenshot count suggests.	Runtime, concurrency, proxy traffic, or endpoint requests are billed separately.	Reconcile each metered unit against usage records and the provider’s plan terms.
Browser hours exceed the estimate.	Slow pages, long waits, idle browser sessions, or retries keep instances running.	Measure duration, close pages and browsers promptly, use targeted readiness waits, and cap retries.
There are extra concurrency charges.	Parallel browser count exceeded an included or averaged concurrency allowance.	Check how concurrency is measured and queue jobs to stay within the intended capacity.
Proxy charges are unexpectedly large.	Pages load substantial resources or use a more expensive proxy category.	Inspect provider traffic logs and its resource-loading defaults; verify the proxy type required for the target.
Credits disappear at renewal.	The subscription terms do not roll credits forward.	Check expiry rules before selecting a prepaid credit plan and size the purchase to realistic usage.
Full-page captures take longer or use more storage.	The page is tall, lazy-loads content, or produces a high-pixel-count image.	Confirm that full-page behavior is needed, test output dimensions, and ask whether the provider meters this configuration differently.
The provider’s advertised unit price does not match the cash cost.	Credits require a plan-specific conversion, or an allowance/overage applies.	Use the selected subscription’s credit conversion and include the base plan and overages in the calculation.

8. Frequently asked questions

Does Playwright charge for `page.screenshot()`?

No hosted per-call price is stated in the reviewed Playwright API documentation. Your execution environment or hosted provider determines infrastructure charges.

Is a browser hour equivalent to a screenshot request?

No. A browser-hour measures time under a runtime-based plan; a request unit counts calls under a request-based plan. Some services may meter both.

Can I compare BrowserCloud credits directly with Cloudflare dollars?

No. The cited BrowserCloud page lists credit quantities, and the cited Cloudflare page lists dollar amounts. A valid comparison needs BrowserCloud’s applicable credit conversion and equivalent workload assumptions.

Do PNG, JPEG, WebP, full-page capture, or device scale always cost extra?

No universal surcharge is established by the reviewed sources. These options can change output size or work performed; the provider’s billing rules determine whether they change the charge.

Which pricing figure should I trust?

Use the current pricing page and terms for the exact product and plan you will use. Published allowances and rates can change, and examples in this article are tied to named providers.