# Website Screenshot Scraper · Full Page, Fast (`automation_craft/website-screenshot-scraper`) Actor

Full-page screenshots that actually work: lazy-loaded content rendered, cookie banners hidden, desktop/mobile/tablet presets, retina, JPEG/PNG, batch URLs. Page title & metadata included free. Seconds per page — and failed pages cost you nothing.

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

## Pricing

Pay per event

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 Scraper — Full Page, Fast

Batch screenshots that actually come out right. Feed it a list of URLs; get back pixel-perfect **full-page captures with lazy-loaded content rendered and cookie banners hidden**, plus the page's title and metadata — in seconds per page, not minutes.

**You only pay for screenshots that succeed.** Pages that fail to load cost you nothing, ever.

### Why this one

Screenshot tools mostly fail the same four ways. This Actor was built specifically against each:

| Common complaint | What this Actor does |
| --- | --- |
| "Full-page" shots are really just the first screen | Real full-page capture: step-scrolls the page so lazy-loaded images render, releases consent-manager scroll-locks that trick other tools into 800px "full pages", then captures the true height (tested on 70,000px+ pages) |
| Slow — minutes per screenshot | Seconds per page; one shared browser, up to 5 pages in parallel |
| Charged even when it fails | Failed or unreachable pages are **$0** and reported with the exact error |
| Cookie popups all over the shot | 40+ consent managers (OneTrust, Cookiebot, Didomi, Sourcepoint, Usercentrics…) hidden by default — nothing is clicked, they're just not in your image |

### What you get per URL

- The **screenshot file** (JPEG or PNG) stored with a direct download link.
- A dataset row: page **title, meta description, og:image, canonical URL, language** (free), HTTP status, final URL after redirects, image dimensions, the page's real full height, capture timings.
- Optional free extras: the page's **visible text** and the **fully rendered HTML** as a linked file — handy when the screenshot is part of a scraping or monitoring pipeline.

```json
{
    "type": "screenshot",
    "url": "https://www.theguardian.com/uk",
    "status": "ok",
    "httpStatus": 200,
    "screenshotUrl": "https://api.apify.com/v2/key-value-stores/…/records/screenshot-001-www.theguardian.com-uk.jpg",
    "format": "jpeg",
    "width": 1280,
    "height": 15000,
    "fullPage": true,
    "truncated": true,
    "fullPageHeight": 24832,
    "device": "desktop",
    "title": "Latest news, sport and opinion from the Guardian",
    "metaDescription": "…",
    "totalMs": 7343
}
```

### Options

- **Devices**: desktop (any viewport 320–3840px wide), mobile (iPhone 390×844 + touch + mobile UA), tablet (iPad 820×1180). **Retina 2×** toggle for crisp print-quality images.
- **Formats**: JPEG (with quality control) or PNG (lossless; supports pages taller than JPEG's 65,000px format limit).
- **Timing**: extra delay, wait-for-selector, per-page timeout.
- **Cleanup**: hide any elements by CSS selector (chat widgets, sticky bars, ads) on top of the built-in cookie-banner hiding.
- **Height cap**: `maxPageHeight` (default 20,000px) stops endless feeds; the item tells you the page's real height and that it was truncated.
- **Batching**: up to 500 URLs per run, concurrency 1–5, duplicates deduped.

Run with empty input `{}` for a live demo (full-page shot of apify.com).

### Use cases

- **Monitoring & archiving**: nightly captures of your pages, competitors, or a client portfolio — pair the screenshot with the free HTML capture for a complete record.
- **Link previews & thumbnails**: generate og-image-style previews for URL lists.
- **Compliance & evidence**: timestamped captures of pages as they appeared, with HTTP status and final URL recorded.
- **QA**: mobile/tablet/desktop renders of the same URL in one run.
- **AI pipelines**: screenshots + page text in one call, ready for vision models.

### Pricing — pay per success, honestly

- One flat fee per **successfully captured screenshot** — any size, any device, full-page or viewport. Metadata, text and HTML extras are free.
- **$0 for failures**: unreachable domains, timeouts, rejected URLs. Each failure is itemized with its reason.
- A page that loads with an error HTTP status (e.g. a 404 page) **is** captured and charged — you asked for that URL, and you get exactly what it looks like, with `httpStatus` recorded so you can filter.

### ✅ What this Actor CAN do

- True full-page screenshots including lazy-loaded content, at up to 100,000px page height (PNG).
- Hide cookie banners on sites using all major consent platforms, without interacting with them.
- Desktop/mobile/tablet presets, retina scaling, JPEG/PNG output.
- Capture pages behind public URLs, including redirects (final URL reported).
- Free page metadata, visible text and rendered HTML alongside every shot.

### ❌ What this Actor CANNOT do

- **Pages behind a login** — no cookie/session support in this version.
- **Accept/reject cookie dialogs on your behalf** — banners are hidden, not clicked, so consent state is never changed.
- **PDF export** — image formats only.
- **Video or animated capture** — single still image per URL.
- Private/internal hosts (localhost, RFC-1918 IPs) are rejected by design.
- A few app-like sites (some SPAs, and sites that gate content behind a login/consent wall for datacenter visitors) render inside an internal scroller and report only one screen of height — those come out as sharp above-the-fold shots rather than full-page ones. The item's `fullPageHeight` always tells you what was measured.

Failed pages are retried once on a fresh browser context before being reported (free) with the exact error.

# Actor input Schema

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

One screenshot per URL. Plain list of page URLs (http/https).

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

Capture the whole page, not just the first screen. Lazy-loaded images are scrolled into existence first. Turn off for an above-the-fold shot.

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

Device preset: `desktop` uses your viewport size below; `mobile` (390×844, iPhone) and `tablet` (820×1180, iPad) set realistic viewport, user agent and touch.

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

Browser width for the `desktop` device (320–3840).

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

Browser height for the `desktop` device (320–2160). This is the screenshot height when `fullPage` is off.

## `retina` (type: `boolean`):

Render at 2× device pixel ratio — crisp images for presentations and print (roughly 4× the file size).

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

`jpeg` is small and fast (quality below applies); `png` is lossless and supports pages taller than 65,000px.

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

1–100, JPEG only. 80 is a good balance.

## `maxPageHeight` (type: `integer`):

Ceiling for full-page captures. Endless-feed pages get cut here instead of running forever; the item reports `truncated: true` plus the real page height. JPEG caps at 65,000px (format limit).

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

Hide 40+ common consent popups (OneTrust, Cookiebot, Didomi, Usercentrics, Sourcepoint…) before capturing. Nothing is clicked — banners are just not in your shot.

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

Extra CSS selectors to hide before the shot — chat widgets, sticky bars, ads. Example: `#intercom-container`.

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

Extra wait after the page settles, for late animations/fonts (0–30000).

## `waitForSelector` (type: `string`):

Only capture after this CSS selector appears — useful for apps that render late.

## `scrollToLoad` (type: `boolean`):

Step-scroll to the bottom before a full-page shot so lazy-loaded images actually render (the #1 cause of blank areas in other tools).

## `capturePageData` (type: `boolean`):

Also store the page title, meta description, og:image, canonical URL and language on the dataset item. No extra charge.

## `captureText` (type: `boolean`):

Also store the page's visible text on the dataset item. No extra charge.

## `captureHtml` (type: `boolean`):

Also save the fully rendered HTML as a linked file. No extra charge.

## `timeoutSecs` (type: `integer`):

Give up on a page after this long (5–300). Failed pages cost nothing.

## `concurrency` (type: `integer`):

Pages captured in parallel (1–5).

## Actor input object example

```json
{
  "urls": [
    "https://apify.com"
  ],
  "fullPage": true,
  "device": "desktop",
  "viewportWidth": 1280,
  "viewportHeight": 800,
  "retina": false,
  "format": "jpeg",
  "quality": 80,
  "maxPageHeight": 20000,
  "dismissCookieBanners": true,
  "delayMs": 0,
  "scrollToLoad": true,
  "capturePageData": true,
  "captureText": false,
  "captureHtml": false,
  "timeoutSecs": 60,
  "concurrency": 3
}
```

# Actor output Schema

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

No description

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

No description

## `files` (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 = {
    "urls": [
        "https://apify.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation_craft/website-screenshot-scraper").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 = { "urls": ["https://apify.com"] }

# Run the Actor and wait for it to finish
run = client.actor("automation_craft/website-screenshot-scraper").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 '{
  "urls": [
    "https://apify.com"
  ]
}' |
apify call automation_craft/website-screenshot-scraper --silent --output-dataset

```

## MCP server setup

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

```

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/2gDkWpB05zB7wY8ej/builds/g1TtheslKwmrghReR/openapi.json