# Website Screenshot Pro – Bulk, Full-Page, Mobile & PDF (`steadyutil/website-screenshot-pro`) Actor

Capture screenshots of any list of websites: full-page or above-the-fold, desktop, laptop, tablet and mobile, PNG/JPEG plus optional PDF. Hides cookie banners, loads lazy images, blocks ads and never fails a whole run on one bad URL.

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

## Pricing

from $3.00 / 1,000 screenshot captureds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Website Screenshot Pro: bulk full-page, mobile and PDF screenshots of any URL

**Website Screenshot Pro** captures clean screenshots of any list of web pages. You can take the full page or just what's visible on screen, on desktop, laptop, tablet and mobile, as PNG or JPEG and optionally as a PDF. It hides cookie pop-ups, scrolls the page so lazy-loaded images appear, can block ads, and keeps going when a site is slow or broken. You pay only for screenshots of pages that actually loaded.

Use it for website monitoring and visual archives, competitor and ad tracking, SEO and agency reports, QA across devices, thumbnails for directories, link previews and AI pipelines that need page images.

### Why use it?

- **Bulk and multi-device in one run.** Every URL × every device you choose (Desktop 1920×1080, Laptop 1366×768, iPad, iPhone 13, Pixel 7, or a custom viewport).
- **Clean screenshots.** Hides 50+ common cookie and consent banners (OneTrust, Cookiebot, Didomi, Quantcast, Usercentrics, TrustArc and more) with CSS. Nothing is clicked or accepted. It also unlocks page scrolling that consent modals block.
- **Lazy-loading handled.** It scrolls through the page before capturing so images and sections below the fold render.
- **Full page or element.** Capture the full page (with a safe height cap for endless pages), only the viewport, or a single element by CSS selector.
- **PDF export, dark mode, custom CSS, hidden elements and ad/tracker blocking.**
- **Robust.** Slow pages that never finish loading are captured once content has rendered. Errors are retried with exponential backoff. Bot-protection and error pages are detected, flagged and **never charged**. One bad URL never fails the whole run.
- **Ready for integrations.** Every result has a direct image URL, so it drops straight into Google Sheets, Airtable, Make, Zapier, n8n or your own code.

### How to use it

1. Paste your **URLs** (domains without `https://` work too).
2. Pick **devices**, **full page** or not, and **PNG or JPEG**.
3. Click **Start**. Images and PDFs are saved in the run's key-value store, and the dataset holds a table with a preview and a link to each one.

#### Input example

```json
{
  "startUrls": [{ "url": "https://apify.com" }, { "url": "https://www.wikipedia.org" }],
  "devices": ["desktop", "mobile"],
  "fullPage": true,
  "format": "jpeg",
  "jpegQuality": 80,
  "hideCookieBanners": true,
  "scrollToBottom": true,
  "savePdf": false,
  "waitUntil": "load",
  "delayMs": 1000
}
```

#### Output example

```json
{
  "url": "https://apify.com/",
  "finalUrl": "https://apify.com/",
  "device": "mobile",
  "deviceLabel": "iPhone 13",
  "viewportWidth": 390,
  "viewportHeight": 664,
  "fullPage": true,
  "format": "jpeg",
  "screenshotUrl": "https://api.apify.com/v2/key-value-stores/<storeId>/records/apify-com-mobile-774f76c3.jpg",
  "screenshotKey": "apify-com-mobile-774f76c3.jpg",
  "pdfUrl": null,
  "imageHeight": 9876,
  "pageHeight": 9876,
  "truncated": false,
  "fileSizeBytes": 812345,
  "statusCode": 200,
  "pageTitle": "Apify: Marketplace of ready-to-run tools for AI",
  "navigationTimedOut": false,
  "loadTimeMs": 6585,
  "success": true,
  "blocked": false,
  "error": null,
  "capturedAt": "2026-11-22T09:32:00.000Z"
}
```

Failed URLs appear with `success: false` and a readable `error`, for example DNS errors, timeouts, HTTP 404 or "Blocked by bot protection". Where the page could still be rendered, the screenshot is kept so you can see what happened.

### Run it from the API

Replace `YOUR_API_TOKEN` with your [Apify API token](https://console.apify.com/account/integrations). The call returns when the run finishes; then read the dataset. Each item includes a public `screenshotUrl` you can store or display.

#### cURL

```bash
curl "https://api.apify.com/v2/acts/steadyutil~website-screenshot-pro/runs?waitForFinish=300" \
  -X POST \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{ "url": "https://apify.com" }, { "url": "https://www.wikipedia.org" }],
    "devices": ["desktop", "mobile"],
    "fullPage": true,
    "format": "jpeg",
    "hideCookieBanners": true
  }'
```

Fetch results (use the `defaultDatasetId` from the run):

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?format=json" \
  -H "Authorization: Bearer YOUR_API_TOKEN"
```

#### JavaScript

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('steadyutil/website-screenshot-pro').call({
    startUrls: [
        { url: 'https://apify.com' },
        { url: 'https://www.wikipedia.org' },
    ],
    devices: ['desktop', 'mobile'],
    fullPage: true,
    format: 'jpeg',
    hideCookieBanners: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const item of items) {
    console.log(item.device, item.screenshotUrl, item.success);
}
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("steadyutil/website-screenshot-pro").call(run_input={
    "startUrls": [
        {"url": "https://apify.com"},
        {"url": "https://www.wikipedia.org"},
    ],
    "devices": ["desktop", "mobile"],
    "fullPage": True,
    "format": "jpeg",
    "hideCookieBanners": True,
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
for item in items:
    print(item["device"], item.get("screenshotUrl"), item["success"])
```

The Actor is also available through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp), so AI agents can discover and call it from the Store page.

### Related Actors

These SteadyUtil Actors combine well with this one:

- [Sitemap URL Extractor Pro](https://apify.com/steadyutil/sitemap-url-extractor-pro) — pull every URL from a site's sitemaps first, then screenshot the list (or only pages modified after a given date).
- [Website Tech Stack Detector & SEO Audit](https://apify.com/steadyutil/website-tech-stack-seo) — detect the CMS, framework and SEO issues of each domain, then screenshot the pages you want to review.

### Automation recipes (Make, n8n, Zapier)

Each recipe starts the same way: in Apify Console, save this Actor as a Task with your input, then connect that Task from Make, n8n or Zapier (search for the Apify app). You can also call the API examples above from an HTTP module.

#### Daily screenshot archive

1. Create a Task with the URLs you monitor, devices (for example desktop and mobile), **Full-page screenshot** on, and JPEG or PNG.
2. Add a **Schedule** in Apify Console (daily or weekly).
3. In Make, n8n or Zapier, trigger on a finished run and save each `screenshotUrl` (and `pdfUrl` if you enabled PDFs) to Google Drive, Dropbox or a Google Sheet, with the URL, device and `capturedAt`.
4. Optional: compare today's image with yesterday's (or just keep a dated folder) for visual change tracking.

#### Competitor or ad-page snapshots to Slack

Use the example Task **Mobile + desktop screenshots of a URL list**. Schedule it, then post the `screenshotUrl` and page title to a Slack channel whenever a run finishes.

#### Screenshots from a sitemap

In n8n or Make, run [Sitemap URL Extractor Pro](https://apify.com/steadyutil/sitemap-url-extractor-pro) with a `lastmodAfter` filter, pass the resulting URLs into this Actor, and archive only the new or changed pages.

### Pricing

Pay-per-event pricing, with no compute charges. Proxy is free unless you choose the residential group:

| Event | Price |
| --- | --- |
| `screenshot`: one successful screenshot (one URL on one device) | **$3.00 per 1,000** ($0.003 each) |
| `pdf`: optional PDF of the same page | **$2.00 per 1,000** ($0.002 each) |
| `residential-proxy-mb`: only if you turn on Apify **residential** proxy, per started MB downloaded through it | **$0.012 per MB** |

Pages that fail, return HTTP errors or show a bot-protection wall are **not charged**. Example: 500 URLs on desktop and mobile is 1,000 screenshots, which costs $3. With residential proxy, a typical page loads 1–5 MB, which adds about $0.01–0.06 per screenshot. Video and audio are skipped to keep this low. Apify Store plan discounts apply automatically.

### FAQ

**How do I take mobile and desktop screenshots of a URL list?**
Paste the URLs, set **Devices** to Desktop and Mobile (iPhone 13), pick full page or viewport, and click **Start**. You'll get one image per URL per device, with a `screenshotUrl` you can download or send to a spreadsheet. Try the public example Task **Mobile + desktop screenshots of a URL list**.

**Will cookie banners still show?**
Most common consent tools are hidden. If a site uses a custom pop-up, add its CSS selector under **Hide elements**.

**A page looks empty or half-loaded.**
Try `waitUntil: networkidle` and a longer **Extra delay** (2,000–5,000 ms) for heavy JavaScript apps.

**Some sites show "Access denied".**
Those sites block datacenter traffic. Enable **Apify Proxy** (residential) in the input. Blocked pages are flagged and not charged.

**How long can a full-page screenshot be?**
Up to 32,000 px (15,000 px by default). Longer pages are cut and marked `truncated: true`.

**Can I take screenshots on a schedule?**
Yes. Create a Task and a Schedule in Apify Console, or use the **Daily screenshot archive** recipe above with Make, n8n or Zapier.

**Can I use it through the API or with AI agents?**
Yes. It works with the Apify API, the JS and Python clients, Make, Zapier, n8n and the Apify MCP server. Copy the examples in **Run it from the API**.

### Support and feedback

Website Screenshot Pro is built and maintained by **SteadyUtil**, a small publisher of reliable, low-cost web utilities on Apify. Found a site that doesn't work, or need a field we don't output yet? Open an issue in the **Issues** tab of this Actor (fastest, usually answered within 1–2 business days) or email **support@steadyutil.com**.

Other SteadyUtil Actors: [Sitemap URL Extractor Pro](https://apify.com/steadyutil/sitemap-url-extractor-pro) and [Website Tech Stack Detector & SEO Audit](https://apify.com/steadyutil/website-tech-stack-seo).

### Legal note

This Actor loads publicly accessible web pages in a normal browser and saves an image of what any visitor would see. It doesn't log in, fill forms, accept cookies on your behalf or collect personal data. Make sure you have the right to capture and use screenshots of the sites you target, and respect their terms and copyright.

# Actor input Schema

## `startUrls` (type: `array`):

Pages to screenshot. Domains without https:// are accepted.

## `devices` (type: `array`):

One screenshot is taken per URL per device. desktop = 1920x1080, laptop = 1366x768, tablet = iPad, mobile = iPhone 13, mobile-android = Pixel 7.

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

Capture the whole scrollable page instead of only the visible viewport.

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

PNG is lossless; JPEG is much smaller.

## `jpegQuality` (type: `integer`):

1-100, only used for JPEG.

## `savePdf` (type: `boolean`):

Saves a PDF of each page next to the image (billed as a separate event).

## `hideCookieBanners` (type: `boolean`):

Hides 50+ common cookie/consent pop-ups (OneTrust, Cookiebot, Didomi, Quantcast, Usercentrics ...) with CSS. Nothing is clicked or accepted.

## `scrollToBottom` (type: `boolean`):

Scrolls through the page before capturing so lazy-loaded images and sections appear.

## `blockAds` (type: `boolean`):

Blocks requests to common ad and tracking networks for cleaner, faster screenshots.

## `darkMode` (type: `boolean`):

Emulates prefers-color-scheme: dark.

## `waitUntil` (type: `string`):

When navigation is considered finished. 'networkidle' is best for heavy single-page apps but slower. If the page never finishes loading, it is captured anyway once something has rendered.

## `delayMs` (type: `integer`):

Wait time after the page has loaded, for animations and late scripts.

## `viewportWidth` (type: `integer`):

Overrides the device width. 0 = use the device preset.

## `viewportHeight` (type: `integer`):

Overrides the device height. 0 = use the device preset.

## `maxFullPageHeight` (type: `integer`):

Very long pages are cut at this height (truncated=true in the output).

## `selector` (type: `string`):

Optional. Screenshot just one element, e.g. #pricing or header.

## `hideSelectors` (type: `array`):

Optional. Elements to hide before capturing, e.g. chat widgets or sticky headers.

## `injectCss` (type: `string`):

Optional CSS injected into the page before capture.

## `navigationTimeoutSecs` (type: `integer`):

Max time to load each page.

## `maxRetries` (type: `integer`):

Retries per URL on errors, with exponential backoff. Failed URLs are reported with success=false and are not charged.

## `maxConcurrency` (type: `integer`):

Parallel browser tabs. Roughly 1 tab per 1 GB of memory (4 GB default = 1 CPU core).

## `proxyConfiguration` (type: `object`):

Optional. Use Apify Proxy (e.g. residential) for sites that block datacenter IPs or to capture a page as seen from a given country. Residential proxy traffic is charged at $0.012 per MB (event residential-proxy-mb); the datacenter proxy has no extra charge.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://apify.com"
    },
    {
      "url": "https://www.wikipedia.org"
    }
  ],
  "devices": [
    "desktop",
    "mobile"
  ],
  "fullPage": true,
  "format": "png",
  "jpegQuality": 80,
  "savePdf": false,
  "hideCookieBanners": true,
  "scrollToBottom": true,
  "blockAds": false,
  "darkMode": false,
  "waitUntil": "load",
  "delayMs": 1000,
  "viewportWidth": 0,
  "viewportHeight": 0,
  "maxFullPageHeight": 15000,
  "hideSelectors": [],
  "navigationTimeoutSecs": 45,
  "maxRetries": 2,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `screenshots` (type: `string`):

No description

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

No description

## `summary` (type: `string`):

No description

# 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 = {
    "startUrls": [
        {
            "url": "https://apify.com"
        },
        {
            "url": "https://www.wikipedia.org"
        }
    ],
    "devices": [
        "desktop",
        "mobile"
    ],
    "fullPage": true,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("steadyutil/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 = {
    "startUrls": [
        { "url": "https://apify.com" },
        { "url": "https://www.wikipedia.org" },
    ],
    "devices": [
        "desktop",
        "mobile",
    ],
    "fullPage": True,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("steadyutil/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 '{
  "startUrls": [
    {
      "url": "https://apify.com"
    },
    {
      "url": "https://www.wikipedia.org"
    }
  ],
  "devices": [
    "desktop",
    "mobile"
  ],
  "fullPage": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call steadyutil/website-screenshot-pro --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,steadyutil/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/tCkzXeoZa3IeNbD6m/builds/Xr6kAY4pXAhLKFwYT/openapi.json
