Browserless Screenshot Pricing in India: Estimate the Cost in Rupees

Short answer: Browserless lists Cloud plan prices in US dollars, not rupees. At the reference rate of ₹96.37 per US dollar on October 3, 2026, its annually billed monthly prices convert to about ₹2,409 for Prototyping, ₹13,492 for Starter, and ₹33,730 for Scale. Those are approximate conversions, not India quotes or final card charges. Screenshot usage is charged by browser time in units of up to 30 seconds, with partial units rounded up; there is no universal fixed price per screenshot.

This guide explains the conversion, how to estimate a workload, what the screenshot endpoint does, and which costs to confirm before choosing a plan. Browserless plan prices, exchange rates and billing terms can change; check the current Browserless pricing page before committing.

Browserless plan prices converted to rupees

The following estimates convert the displayed annually billed monthly prices using ₹96.37/USD. The USD plan amounts and included monthly units come from Browserless’s pricing page; the INR figures are arithmetic based on the dated reference rate.

Plan	Published price	Approx. INR/month	Included units/month
Free	$0	₹0	1,000
Prototyping	$25/month, billed annually	₹2,409	20,000
Starter	$140/month, billed annually	₹13,492	180,000
Scale	$350/month, billed annually	₹33,730	500,000
Enterprise	Custom	Not calculable from a public list price	Custom

These numbers do not include taxes, payment-provider fees, or any exchange-rate margin applied by a card issuer or bank. The pricing page also offers monthly billing, but the research available for this estimate does not establish a separate monthly-billing price for every tier. Confirm the billing cycle and price displayed for your account.

Sources: Browserless Cloud pricing and the PaisaDesk reference rate for October 3, 2026. The exchange rate is an input for illustration, not a guaranteed settlement rate.

How screenshot requests consume units

Browserless defines units as the billing currency for platform activity. Browser time is charged in 30-second increments, and a partial increment rounds up. A browser connection lasting 31 seconds therefore consumes two units. Browser time applies across BrowserQL, BaaS and REST APIs, including the screenshot REST endpoint. That means the cost depends on session duration and plan allowance, not only the number of images.

Some paid plans list overage rates: $0.0020 per unit for Prototyping, $0.0017 for Starter, and $0.0015 for Scale in the retrieved pricing material. These rates and plan terms are subject to change; verify the live page before using them in a budget.

Estimate your monthly screenshot budget

1. Count monthly browser sessions. Count requests that open a browser connection, including retries or other browser tasks if they use the same account.
2. Estimate connection time per session. Include navigation, page rendering, any waits or scrolling, and the screenshot operation. Use observed duration from your own workload when available; do not assume every site finishes equally quickly.
3. Round each session up to 30 seconds. A 10-second session uses one unit; a 31-second session uses two. For a simple planning estimate, units per request are ceil(session_seconds / 30).
4. Multiply by monthly volume. Estimated monthly units are requests_per_month × ceil(seconds_per_session / 30) when durations are similar. For mixed durations, calculate and sum each session’s rounded units.
5. Compare with the plan allowance. Check included units, overage rates, concurrency and maximum session time on the current plan page.
6. Convert the plan amount to INR. Multiply the USD list price by your chosen USD/INR reference rate. Add a buffer for exchange-rate movement, taxes and payment fees.

Example: Suppose a workload makes 2,000 screenshot sessions per month and each connection takes about 20 seconds. Each session consumes one unit, so the estimate is 2,000 units monthly. At 45 seconds per session, each uses two units, or 4,000 units monthly. This is a unit calculation, not a claim about actual Browserless performance or a quoted bill.

Use the pricing page’s current included allowance and overage rules to decide whether that volume fits. The published free allowance is 1,000 units monthly, so a workload estimated above that allowance should account for a paid tier or other applicable terms.

Capture a screenshot with Browserless REST

The documented endpoint is a POST request to /screenshot, authenticated with an API token. A request can provide a page URL or raw HTML and screenshot options; the response is an image in PNG, JPEG or WebP. Check Browserless’s screenshot REST documentation for the current request schema and supported options.

cURL

curl -X POST "https://production-sfo.browserless.io/screenshot?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  --data '{"url":"https://example.com","options":{"fullPage":true}}' \
  --output screenshot.png

Use the endpoint host assigned to your Browserless account if it differs. The example shows the common URL plus full-page options; confirm exact accepted fields and authentication format in the current documentation for your deployment.

Python

import requests

endpoint = "https://production-sfo.browserless.io/screenshot"
response = requests.post(
    endpoint,
    params={"token": "YOUR_API_TOKEN"},
    json={
        "url": "https://example.com",
        "options": {"fullPage": True},
    },
    timeout=90,
)
response.raise_for_status()
with open("screenshot.png", "wb") as image:
    image.write(response.content)

Node.js

const endpoint = new URL("https://production-sfo.browserless.io/screenshot");
endpoint.searchParams.set("token", "YOUR_API_TOKEN");

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

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

const image = Buffer.from(await response.arrayBuffer());
await import("node:fs/promises").then(({ writeFile }) => writeFile("screenshot.png", image));

Relevant screenshot options and page behavior

The screenshot API supports full-page capture, output format and quality, viewport size, a clip region, device scale factor, and element selection. Use the options documented for the endpoint version you call. These settings affect the content and output size; page behavior can also affect how long the browser connection remains open, which affects unit consumption.

• Full page: captures beyond the initial viewport. Pages with lazy-loaded content may need scrolling before the capture; a full-page flag alone may not trigger every site’s lazy content.
• Viewport: set width and height when the output must match a target layout. Responsive pages may show different content at different dimensions.
• Clip region: capture a defined rectangle when only a portion is needed.
• Element selection: select a specific page element where supported. Missing or dynamically rendered elements can lead to an incomplete capture.
• Format and quality: choose PNG, JPEG or WebP as supported. JPEG quality applies to lossy output formats; validate the returned content type and file extension.
• Device scale factor: increase pixel density when a sharper image is needed, while considering the larger output and processing requirements.
• URL or HTML input: use a URL for a live page or raw HTML for a controlled document, following the endpoint’s schema.

Browserless documentation notes that bot detection can result in blank captures, CAPTCHA pages, access-denied responses or missing elements. Do not budget on the assumption every target will return a complete screenshot in a fixed duration.

Reliability, performance and cost controls

• Keep waits deliberate. Every extra wait can extend browser time and may cross a 30-second boundary. Wait only for content your capture requires.
• Handle slow and variable pages. Track request duration and outcomes by target site. Use timeouts and bounded retries so one slow page does not create unbounded work.
• Account for retries. A retry may create another browser session and consume units. Classify errors before retrying; repeated retries against a CAPTCHA or access-denied page are unlikely to fix the underlying issue.
• Control concurrency. Compare expected parallel sessions with the selected plan’s current concurrency allowance and session-time limits.
• Validate output. Check HTTP status, response content type and whether the file can be decoded as an image. A successful transport alone does not guarantee the intended page content was captured.
• Monitor usage. Compare actual unit consumption with request counts and session durations. Investigate large differences, long-tail pages and repeated failures.

There is no defensible universal cost per image without assumptions about session duration, retries and plan. For a stable budget, use representative request volumes and measured session times, then model rounded units and the selected plan’s current allowance and overage terms.

Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server. One GET request returns a PNG, JPEG or WebP screenshot, or a PDF. Its clean capture flow accepts the cookie or consent banner like a visitor and removes 60+ known consent platforms, newsletter popups and chat widgets before capture; each step can be turned off. Only clean shots are billed: bot checks or CAPTCHAs, blank pages, timeouts, failed loads and cache hits cost nothing, and each response reports the page verdict and billing status.

It also provides an MCP server with take_screenshot, get_page_info and capture_pdf tools for AI agents. The free plan includes 1,000 shots a month with no card, and paid plans start at $5 for 3,000 shots. See the ScreenshotNeo API documentation.

cURL

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

Python

import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://example.com"}, timeout=90)
open("shot.webp", "wb").write(r.content)

Node.js

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://example.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);
if (!res.ok) throw new Error(`ScreenshotNeo request failed: ${res.status}`);
const fs = await import('node:fs/promises');
await fs.writeFile('shot.webp', Buffer.from(await res.arrayBuffer()));

Try ScreenshotNeo with 1,000 free screenshots a month with no card.

Troubleshooting Browserless screenshot requests

Symptom	Likely cause	What to check
Authentication failure	Missing, malformed or invalid token	Confirm the account token and endpoint host, and keep the token out of public client-side code.
Request rejected	Invalid JSON or unsupported option names/types	Compare the payload with the current REST screenshot schema; reduce to a URL-only request, then add options one at a time.
Blank image	Page did not render, bot detection, or capture occurred before useful content appeared	Inspect the target in a browser, check the response and logs, and configure the documented wait or browser behavior appropriate to the page.
CAPTCHA or access-denied page	The target’s bot protections blocked or challenged the browser session	Do not treat the challenge page as the intended screenshot. Check whether the target permits automated access and whether Browserless documents a suitable configuration.
Lazy images or lower-page content missing	Content loads only after scrolling or entering the viewport	Use an approach that scrolls through the page before capture, where supported, and verify the resulting image.
Element capture is missing	Selector is wrong or element appears after the capture point	Verify the selector against the live page and wait for the element to exist before requesting its capture.
Request times out or costs more units than expected	Slow navigation, long waits, retries, or a session crossing another 30-second boundary	Measure connection duration, bound waits and retries, and recalculate units with round-up billing.
Unexpected INR charge	Exchange-rate margin, taxes, provider fees or a different billing cycle	Compare the USD invoice and billing cycle with the card or bank conversion details; treat this article’s INR figures as estimates.

Frequently asked questions

Does Browserless charge a separate fixed fee for each screenshot?

The documented billing basis is browser time in units, so the cost of a screenshot depends on session duration and plan terms rather than a universal fixed per-image price.

Are the rupee amounts official Browserless India prices?

No. They are conversions of public USD list prices at a dated reference rate. They do not include taxes or payment-provider conversion costs.

Can a screenshot request return a PDF?

The documented REST /screenshot endpoint returns an image. Consult Browserless documentation for the appropriate PDF workflow rather than treating screenshot output as a PDF.

Will full-page mode capture every lazy-loaded image?

Not necessarily. Browserless warns that lazy-loaded content may need scrolling before capture, and page-specific behavior can vary.

Which price should I use if I pay monthly?

Use the price shown for the billing cycle selected on Browserless’s live pricing page or in your account. The annual-billing conversions in this guide should not be substituted for an unverified monthly price.