BrowserStack Screenshots Alternatives for Full-Page Website Captures
Need full-page website screenshots? Playwright documents a self-managed option, while ScreenshotNeo offers a hosted API. Here’s how to choose and implement them.
If you need a screenshot of an entire website page rather than only the visible viewport, Playwright is the clearest documented self-managed alternative in the sources reviewed: call page.screenshot({ fullPage: true }). For a hosted screenshot API, ScreenshotNeo is the alternative to try first: it captures a URL with one request, removes known cookie banners, popups and chat widgets before capture, and bills only clean shots.
One scope distinction matters: the BrowserStack full-page guide cited here documents App Percy screenshots for native apps. It does not establish that BrowserStack Screenshots has the same full-page website-capture workflow. Verify the exact BrowserStack product and current capabilities before choosing it for web pages.
What “full-page” means here
A full-page web screenshot includes the page’s scrollable content, including content below the initial viewport. Playwright describes its full-page capture as taking a screenshot of the full scrollable page as if it fit on a very tall screen. This is distinct from capturing a fixed viewport, and it is also distinct from scrolling through a native app screen.
“BrowserStack Screenshots” and “App Percy” should not be treated as interchangeable names. The cited BrowserStack guide is specifically for App Percy and native apps. It describes a beta full-page mode with a configurable number of device screen lengths. That documentation is not proof of equivalent behavior in BrowserStack Screenshots for websites.
Options supported by the reviewed sources
| Option | What the sources establish | Best fit |
|---|---|---|
| ScreenshotNeo | Hosted website screenshot API; one GET request can return an image or PDF. It includes full-page capture with lazy images loaded, and clean-shot billing rules. | Repeatable URL captures without maintaining browser setup. |
| Playwright | Browser automation with documented full-scrollable-page capture through fullPage: true. The screenshot API also accepts image-format, clipping and quality options. |
Developers who want to run and maintain capture code themselves. |
| BrowserStack App Percy | The cited full-page guide is for native apps. It describes up to ten screen lengths, with a default of four, and labels the feature beta. | Investigate only when the target is the native-app workflow the guide covers. |
The reviewed evidence is not enough to rank a broader market of hosted screenshot vendors or to make a price-versus-fidelity comparison. When evaluating another option, check whether it captures web pages or native apps, supports dynamic and lazy content, offers the browser and device coverage you need, fits your export and automation workflow, and makes its quotas and billing rules clear.
Capture a full web page with Playwright
This Node.js example opens a page and writes a full-page PNG. Install Playwright and its Chromium browser, save the code as capture.mjs, then run it with Node.js.
npm install playwright
npx playwright install chromium// capture.mjs
import { chromium } from 'playwright';
const url = process.argv[2] ?? 'https://example.com';
const browser = await chromium.launch({ headless: true });
try {
const page = await browser.newPage({ viewport: { width: 1440, height: 900 } });
await page.goto(url, { waitUntil: 'networkidle', timeout: 60_000 });
await page.screenshot({ path: 'screenshot.png', fullPage: true });
console.log('Saved screenshot.png');
} finally {
await browser.close();
}node capture.mjs https://example.comThe example uses networkidle to wait for network activity to settle. Some sites keep analytics, polling or streaming connections open, so this condition may never arrive. For those pages, use domcontentloaded or load, then wait for the particular content you need with a locator or a short, deliberate delay.
Image format, clipping and quality
Playwright’s screenshot API supports image-format, clipping and quality parameters in addition to fullPage. For example, JPEG output can reduce file size when transparency is unnecessary. Quality applies to JPEG; PNG is lossless. A clip is useful for a known region, but it changes the capture area, so do not combine it with a full-page goal unless the intended result is a specific crop. See the Playwright screenshots documentation for the current API details.
await page.screenshot({
path: 'screenshot.jpg',
type: 'jpeg',
quality: 80,
fullPage: true
});Dynamic and lazy-loaded pages
A full-page screenshot captures the page state available to the browser. A page may not have loaded content far below the fold yet, even if the screenshot covers the full scrollable height. If the site loads content on scroll, scroll through the page before capturing, wait for the relevant images or selectors, or use a capture service that explicitly handles lazy images. Keep any scrolling loop bounded: infinite-scroll pages can otherwise grow without limit.
For repeatable results, set a stable viewport, wait for a meaningful page condition, and use a deterministic URL and browser state. Authentication, consent choices, animations, personalized content and changing data can all change the captured result.
Or skip the browser setup
ScreenshotNeo provides a hosted website screenshot API and MCP server. Its full-page option loads lazy images; known cookie and consent banners, newsletter popups and chat widgets can be removed before capture. Bot checks, blank pages, timeouts, failed loads and cache hits are not billed, and the response identifies the page verdict and billing status in headers. AI agents can use its MCP tools, including take_screenshot, get_page_info and capture_pdf.
Here is a one-request cURL capture; replace the placeholder with your API key. The API also accepts the parameter names used by other screenshot APIs, which can simplify migration. See the ScreenshotNeo API documentation for parameters and response details.
curl -G "https://api.screenshotneo.com/v1/shot" \
-d access_key=YOUR_API_KEY \
--data-urlencode url=https://stripe.com \
-o shot.webpEquivalent Python and Node.js requests:
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)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, 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. The free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000. Create a free ScreenshotNeo account.
BrowserStack App Percy: keep the scope straight
The cited App Percy guide concerns full-page screenshots of native apps that require scrolling. It says fullPage defaults to false; when enabled, screenLengths can set the number of device screen lengths. The default is four, values above ten reset to ten, and the guide labels the feature beta. These details describe that App Percy feature, not a verified BrowserStack Screenshots website workflow. See the App Percy full-page guide.
BrowserStack’s pricing page describes paid Percy visual-comparison plans and screenshot quotas. Those prices and plan details can change, and they concern Percy; the cited page does not establish the price of BrowserStack Screenshots itself. Check the live pricing page and exact product before budgeting: BrowserStack pricing.
Choosing an approach
- Choose Playwright when you want code-level control, can maintain browser installation and runtime, and need a repeatable script integrated into your own jobs.
- Choose a hosted screenshot API such as ScreenshotNeo when you want to submit URLs without operating the capture browser, need full-page capture, or want API and agent workflows.
- Evaluate App Percy for its documented native-app use case if that is what you need. Confirm whether the exact BrowserStack product you intend to buy supports your website capture requirement.
- Compare workflow details before committing: target type, dynamic-content handling, browser/device scope, exports, automation integration, quota, and what events are billable.
Performance, reliability and cost
Performance
Full-page images can be tall and large. Choose the smallest viewport and output format that meet your use case; JPEG quality can reduce file size for photographic pages, while PNG preserves lossless detail. Capture only the required page or region when a complete page is unnecessary. For lazy content, waiting for every network request may be slower or impossible on sites with persistent connections; wait for a specific selector or bounded condition instead.
Reliability
Browser automation puts browser installation, page timeouts, process cleanup and concurrency limits in your application’s hands. Close the browser in a finally block, use explicit timeouts, and avoid assuming every site reaches network idle. Hosted services move browser operations behind an API, but you should still inspect response status and page-verdict headers, handle timeouts, and retry only transient failures. ScreenshotNeo states that failed loads and cache hits are not billed; consult its docs for the precise response signals.
Cost
Playwright is a self-managed code path; account for the compute, storage and engineering time needed to operate it. The dossier does not provide a BrowserStack Screenshots price, and Percy pricing is separate and subject to change. ScreenshotNeo’s listed monthly tiers are Free: 1,000 shots; 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 every feature is on every plan. Confirm current pricing before purchase.
Troubleshooting
| Symptom | Likely cause | Fix |
|---|---|---|
| Screenshot stops at the viewport | The screenshot call omitted fullPage: true. |
Set fullPage: true in the Playwright screenshot options. |
| Capture hangs waiting for navigation | The site keeps network requests open, so networkidle is never reached. |
Use domcontentloaded or load, then wait for a target selector with a timeout. |
| Lower-page images are missing | Images or sections load only after scrolling or becoming visible. | Scroll in bounded increments, wait for the relevant content, and verify the page’s lazy-loading behavior. |
| Full-page output is unexpectedly huge | The page is very long, an infinite-scroll feed grew, or the viewport is wider than needed. | Bound scrolling, use a suitable viewport, and consider a targeted clip if the complete page is not required. |
| Repeated captures differ | Dynamic content, animations, personalization or session state changed. | Use a stable test URL and browser state; wait for a deterministic selector and disable or wait out animations where appropriate. |
| BrowserStack guide seems not to match website capture | The cited full-page instructions are for App Percy native-app screenshots. | Confirm the product and target type in current BrowserStack documentation before relying on that capability. |
| ScreenshotNeo response is not an image | The request may have returned an error or a non-clean page verdict. | Check the HTTP status and response headers, including X-Page-Verdict and X-Billed, and review the API docs for the outcome. |
FAQ
Does fullPage: true capture an infinite-scroll site forever?
No. It captures the page state and scrollable area available to the browser at capture time. If scrolling creates more content, use a bounded loading strategy.
Is App Percy’s screen-length setting a BrowserStack Screenshots website option?
The cited guide does not establish that. It documents App Percy’s native-app full-page feature.
Can I use full-page capture for visual regression?
A full-page image can be an input to a visual comparison workflow, but the reviewed Playwright documentation only establishes screenshot capture. It does not establish a turnkey visual-testing service.
Which option has the clearest documented full-page website workflow here?
Playwright documents it directly through fullPage: true. For a managed API alternative, ScreenshotNeo offers full-page capture and a one-request URL workflow.
