# Website Screenshot — Full Page, Lazy-Load Safe, Batch, Mobile (`eliai/website-screenshot-pro`) Actor

Full-page website screenshots that wait for lazy-loaded images and fonts, and dismiss cookie banners. Batch up to 100 URLs, desktop/mobile/retina, dark mode, PNG or JPEG. $0.0048 per screenshot produced — failed URLs never charged.

- **URL**: https://apify.com/eliai/website-screenshot-pro.md
- **Developed by:** [Anthony Snider](https://apify.com/eliai) (community)
- **Categories:** Developer tools, Automation, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.80 / 1,000 captured screenshots

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Website Screenshot Pro — full-page shots that actually wait for the page

Screenshot any page, or a whole batch, at desktop / laptop / tablet / mobile sizes. Full-page
captures that include lazy-loaded images instead of cutting them off, with cookie banners
dismissed so they aren't sitting across your shot.

No API key. No signup. Pay per screenshot produced — a URL that fails is never charged.

Use it as a website screenshot API for thumbnails, visual archives, link previews, monitoring,
SEO audits, or agent pipelines: full-page PNG or JPEG capture of any URL, desktop or mobile
viewport, retina scale, dark mode, batch of up to 100 URLs in one run.

***

### Why shots come out wrong elsewhere, and what this does about it

| The usual problem | What this actor does |
|---|---|
| Lazy-loaded images render as blank boxes | Scrolls the entire page to trigger loading, returns to top, *then* captures |
| Web fonts swap mid-capture, text looks wrong | Waits on `document.fonts.ready` before shooting |
| A cookie banner covers the content | Best-effort dismissal of common consent buttons (can be turned off) |
| Full-page capture is clipped | True `fullPage` capture, with the real page height reported back |
| One URL per run | Batch input — and one bad URL never aborts the others |
| A failed run still costs you | Only successful screenshots are billed |

### Input

```json
{ "url": "https://example.com", "device": "desktop", "fullPage": true }
```

Batch, mobile, dark mode:

```json
{
  "urls": ["https://a.com", "https://b.com"],
  "device": "mobile",
  "colorScheme": "dark",
  "format": "jpeg",
  "quality": 85
}
```

| Field | Type | Default | Notes |
|---|---|---|---|
| `url` / `urls` | string / array | — | One page, or a batch |
| `device` | `desktop` | `laptop` | `tablet` | `mobile` | `desktop` | Tablet 2×, mobile 3× retina |
| `fullPage` | boolean | `true` | Whole page vs viewport only |
| `format` | `png` | `jpeg` | `png` | JPEG for smaller files |
| `quality` | integer 1–100 | `85` | JPEG only |
| `colorScheme` | `light` | `dark` | `light` | Renders the page's dark mode |
| `dismissCookieBanners` | boolean | `true` | Best effort, never fails the shot |
| `extraWaitMs` | integer | `500` | Extra settle time for animations |
| `maxUrls` | integer | `20` | Cap, and therefore your budget cap |

### Output

One record per URL. Successful captures include a direct image URL:

```json
{
  "url": "https://example.com",
  "ok": true,
  "status": 200,
  "title": "Example Domain",
  "device": "desktop",
  "viewport": "1920x1080",
  "deviceScaleFactor": 1,
  "fullPage": true,
  "format": "png",
  "pageWidth": 1920,
  "pageHeight": 4310,
  "bytes": 812344,
  "tookMs": 3120,
  "screenshotUrl": "https://api.apify.com/v2/key-value-stores/.../records/example-com-1920xfull.png"
}
```

Failures are returned, not thrown:

```json
{ "url": "https://broken.example", "ok": false, "error": "net::ERR_NAME_NOT_RESOLVED", "tookMs": 1200 }
```

### For agents and automation

- **Capability:** capture a rendered screenshot of one or many web pages
- **Required input:** `url` or `urls`
- **Returns:** one JSON record per URL; `screenshotUrl` is a directly fetchable image
- **Bounded:** `maxUrls` caps the run; failures isolate per URL
- **Side effects:** none — reads the page, stores images in this run's key-value store
- **Determinism:** layout-dependent; identical input on an unchanged page yields an equivalent image

### Pricing — $0.0048 per screenshot, failures free

Pay-per-event: one flat **$0.0048** per screenshot actually **produced**. A URL that fails —
DNS error, timeout, dead page — is returned as an `{ok: false}` record and is **never charged**.

Compared with other paid screenshot actors on Apify (prices checked 2026-08-07):

| Actor | Price | Billing unit |
|---|---|---|
| **This actor** | **$0.0048** | per screenshot produced — failures free |
| i-scraper/website-screenshot | $0.006 | per dataset item |
| crawlerbros/screenshot-url | $0.01 | per actor start — a failed run still bills |
| onescales/website-screenshot-pro | per-start fee | plus your own platform compute |

That is 20% under the cheapest per-screenshot incumbent and less than half of per-start
billing, with the honesty guarantee on top: you pay for images, not attempts.

### Limits (honest ones)

- Pages that hard-block headless browsers (aggressive bot walls) may fail; you are not charged.
- Cookie-banner dismissal is best-effort pattern matching — exotic consent widgets can survive it.
- Full-page capture walks up to 60,000px of page height; beyond that the capture is of the walked region.
- Batch cap is 100 URLs per run (`maxUrls`).

# Actor input Schema

## `url` (type: `string`):

The page to screenshot.

## `urls` (type: `array`):

Screenshot many pages in one run. One failing URL never stops the rest.

## `device` (type: `string`):

Viewport preset. Mobile and tablet capture at retina scale.

## `fullPage` (type: `boolean`):

Scrolls the whole page first so lazy-loaded images and fonts are actually present. Turn off for viewport-only.

## `format` (type: `string`):

PNG is lossless; JPEG is smaller and supports the quality setting.

## `quality` (type: `integer`):

1-100. Only applies to JPEG.

## `colorScheme` (type: `string`):

Render the page in light or dark mode.

## `dismissCookieBanners` (type: `boolean`):

Best-effort click on common consent buttons so the banner does not cover your screenshot.

## `extraWaitMs` (type: `integer`):

Add time for animations or slow widgets to settle.

## `maxUrls` (type: `integer`):

Safety cap. You are charged per screenshot produced, so this is also your budget cap.

## Actor input object example

```json
{
  "url": "https://apify.com",
  "device": "desktop",
  "fullPage": true,
  "format": "png",
  "quality": 85,
  "colorScheme": "light",
  "dismissCookieBanners": true,
  "extraWaitMs": 500,
  "maxUrls": 20
}
```

# Actor output Schema

## `results` (type: `string`):

Every item this run produced, as JSON.

## `resultsCsv` (type: `string`):

The same items as a spreadsheet-ready CSV.

## `files` (type: `string`):

Files this run produced (images, screenshots, reports).

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "url": "https://apify.com"
};

// Run the Actor and wait for it to finish
const run = await client.actor("eliai/website-screenshot-pro").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "url": "https://apify.com" }

# Run the Actor and wait for it to finish
run = client.actor("eliai/website-screenshot-pro").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "url": "https://apify.com"
}' |
apify call eliai/website-screenshot-pro --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,eliai/website-screenshot-pro"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/wC1SpzIfzummVoyxr/builds/EEESQcfmQrWRkJlYW/openapi.json