# Website Screenshot & PDF API (Bulk, No Cookie Banners) (`atesen-software/website-screenshot-pdf-api`) Actor

Screenshot API for URL lists: full page PNG, JPEG or PDF per URL with the cookie and GDPR banner removed. Desktop, tablet and mobile presets, dark mode, element crop, wait for a selector. Blocked or failed pages are not charged.

- **URL**: https://apify.com/atesen-software/website-screenshot-pdf-api.md
- **Developed by:** [Atesen Software](https://apify.com/atesen-software) (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

$4.00 / 1,000 one delivered screenshot or pdf files

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 & PDF API (Bulk, No Cookie Banners)

### Use via API

**Website Screenshot & PDF API** is a bulk **screenshot API**: it takes a list of public URLs and turns each one into a **full page screenshot** as **PNG, JPEG or PDF** (URL to PNG, URL to PDF), with a **cookie banner remover** for cookie and GDPR pop-ups built in. Pick desktop, tablet or mobile (or all three), crop to one element, wait for a selector, or switch to dark mode. Every file gets a download link in the dataset, so you can call this **website screenshot** tool from code, from a schedule or from a no-code tool.

It is built for the job "here is my URL list, give me clean captures": **website screenshot bulk** runs for SEO and design audits, visual archives, change monitoring, client reports, marketplace and ad-creative checks, and evidence copies of public pages.

**What it does not do:** it does not log in, it takes no cookies, passwords or session tokens as input, and it does not solve captchas or get around bot protection. Pages behind a login are out of scope. Pages that answer with an access error (401, 403, 429) or show a bot check that the Actor recognizes come back as `blocked` and are free.

```bash
curl -X POST "https://api.apify.com/v2/acts/atesen-software~website-screenshot-pdf-api/run-sync-get-dataset-items?timeout=120" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"urls":["https://example.com"],"formats":["png"],"devices":["desktop"],"fullPage":true}'
```

**JavaScript** (`npm install apify-client`):

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('atesen-software/website-screenshot-pdf-api').call({ urls: ["https://example.com"], formats: ["png"], devices: ["desktop"], fullPage: true });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Use with AI agents (MCP)

Claude Desktop, Cursor, VS Code and other MCP clients can call this Actor as a tool through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp). Load only this Actor with:

```text
https://mcp.apify.com?tools=atesen-software/website-screenshot-pdf-api
```

Client config (sign in with Apify OAuth when the browser opens, or add an `Authorization: Bearer <APIFY_TOKEN>` header instead):

```json
{
  "mcpServers": {
    "apify": { "url": "https://mcp.apify.com?tools=atesen-software/website-screenshot-pdf-api" }
  }
}
```

Then ask in plain words, for example: "Take a full-page desktop screenshot of https://example.com without the cookie banner." The agent fills the same input fields you see on the Input tab, and runs are billed to your Apify account at the prices on the Pricing tab.

### Why use this screenshot API?

- **Batch by default.** Paste hundreds of URLs, get one dataset row per URL, device and format.
- **Cookie banner remover for clean captures.** Clicks the reject or dismiss button of some well-known consent tools where it can, hides cookie banners, consent walls and their dark overlays, and unlocks page scrolling. It works for common consent tools and many standard banners, not for every site. If one stays on a page, add its selector to "Hide elements".
- **Full page screenshot that works.** The page is scrolled first so lazy-loaded images appear. Very long pages are cut at 16,384 device pixels (the Chrome limit) and marked `truncated`.
- **Mobile, tablet, desktop presets** with real touch and mobile user agent, plus an optional custom viewport.
- **PNG, JPEG and PDF** from one page load. Choose paper size and orientation for PDFs.
- **Element crop** with a CSS selector, **hide elements** (chat widgets, sticky ads), **wait for selector**, dark mode.
- **You pay for delivered files only.** Blocked, failed and rejected pages are free, and the Actor stops cleanly when your maximum cost per run is reached.
- Apify platform extras: schedules, webhooks, API access, integrations, run history.

### What data does it return?

One dataset row per URL, device and format:

| Field | Description |
|---|---|
| `url`, `finalUrl` | The URL you gave and where the browser ended after redirects |
| `status` | `ok`, `blocked`, `failed` or `rejected` (only `ok` is charged) |
| `fileUrl`, `fileKey` | Public download link and key-value store key of the file |
| `format`, `device` | `png`, `jpeg`, `pdf` and `desktop`, `tablet`, `mobile` |
| `width`, `height`, `bytes`, `pages` | Size of the delivered file (`pages` for PDFs) |
| `httpStatus`, `title` | HTTP status and page title |
| `cookieBannerRemoved`, `truncated`, `fullPage` | What was done to the page |
| `error`, `notes` | Why a file was not delivered, and remarks |

### How to take website screenshots in bulk

1. Open the Actor and paste your URLs, one per line. Bare domains like `example.com` work.
2. Choose formats (PNG, JPEG, PDF) and device presets.
3. Leave "Remove cookie and GDPR banners" on, and "Full page" on if you want the whole page.
4. Start the run. Download files from the dataset links, or call the Actor from the API.

### How much does it cost?

Pricing is pay per event: **one charge for each screenshot or PDF file that is delivered**. See the pricing shown at the top of the Actor page for the current price. Pages that are blocked, time out, return an HTTP error, miss your selector or are rejected are not charged. Set a maximum cost per run in the run options and the Actor stops cleanly at that limit. Platform usage for the browser is included in the event price.

### Input

See the **Input** tab for every option. The main ones:

```json
{
  "urls": ["https://example.com", "https://example.org", "https://www.wikipedia.org"],
  "formats": ["png", "pdf"],
  "devices": ["desktop", "mobile"],
  "fullPage": true,
  "removeCookieBanners": true,
  "darkMode": false,
  "selector": "",
  "waitForSelector": "",
  "waitMs": 1000
}
```

- A PDF is made once per URL, from the first device in your list.
- `selector` crops PNG and JPEG to one element. PDFs always contain the whole page.
- `waitForSelector` and `timeoutSecs` fail a URL (free) when the page is not ready in time.
- `captureErrorPages` lets you capture HTTP error pages and charge them like any other page.

### Output

You can download the dataset in various formats such as JSON, HTML, CSV or Excel. Example rows:

```json
[
  {
    "url": "https://example.com",
    "finalUrl": "https://example.com/",
    "httpStatus": 200,
    "title": "Example Domain",
    "device": "desktop",
    "format": "png",
    "status": "ok",
    "width": 1440,
    "height": 900,
    "bytes": 48854,
    "fileUrl": "https://api.apify.com/v2/key-value-stores/EXAMPLEstoreId1/records/shot-0001-example.com-desktop.png",
    "cookieBannerRemoved": false,
    "error": null
  },
  {
    "url": "https://news.example.org/story",
    "httpStatus": 403,
    "device": "desktop",
    "format": "png",
    "status": "blocked",
    "fileUrl": null,
    "error": "HTTP 403: the site refused the request"
  }
]
```

### Tips

- Use `fullPage: false` for a quick first-screen capture; it is the cheapest in run time.
- Very long pages (news home pages, endless feeds) need more memory. Use 4096 MB and a low "Parallel pages" value for them.
- Add `waitMs` or `waitForSelector` for pages that build their content with scripts.
- Use `hideSelectors` for chat widgets and sticky promotions that the banner remover does not cover.
- Large lists: one run handles up to 20,000 URL and device combinations. With the default 2048 MB and 2 parallel pages, expect roughly 5 to 15 delivered files per minute, depending on how heavy the pages are (measured on news home pages and simple sites). The default run timeout is one hour, so for thousands of files split the list into several runs, or raise the timeout, the memory and "Parallel pages" in the run options.

### FAQ

#### Does it bypass captchas, paywalls or bot protection?

No. Those pages are reported as `blocked` and are free.

#### Can it capture pages behind a login?

No. There is no login, cookie or session input. Only public pages are supported.

#### Which URLs are rejected?

Anything that is not `http` or `https`, URLs with a user name or password, `localhost`, and addresses in private or internal networks (10.x, 172.16-31.x, 192.168.x, 127.x, 169.254.x, IPv6 loopback and local ranges). Redirects and page resources that lead to such addresses are blocked too. Rejected URLs are free.

#### Does dark mode work on every site?

Dark mode asks the page for its dark color scheme. Only sites that ship a dark theme change their look.

#### Is it legal to capture a page?

You are responsible for what you capture and how you use it. Check the terms of the site and the rules for the content you copy. This Actor does not collect personal data on its own, but a screenshot shows whatever the page shows, including any personal data on it. Our Actors are ethical and do not extract private user data, but screenshots can contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. If you are unsure whether your use is legitimate, consult your lawyers.

#### Something looks wrong. Where do I report it?

Open the Issues tab of this Actor with the URL and your input, and describe what you expected. Programmatic access is on the API tab.

Made by Atesen Software.

### Related actors

- [URL to Markdown Converter for RAG: Pages, PDFs & Sitemaps](https://apify.com/atesen-software/url-to-markdown-rag)
- [Bulk Image Downloader: Download Images from a URL List to ZIP](https://apify.com/atesen-software/bulk-image-downloader)
- [SEO Audit Tool & Broken Link Checker: Website Crawler](https://apify.com/atesen-software/website-seo-audit)

# Actor input Schema

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

Public web pages to capture, one per line. http and https only. Pages that need a login are not supported. Addresses inside private networks (localhost, 10.x, 192.168.x and similar) are rejected.

## `formats` (type: `array`):

File types to create for each URL. Every delivered file is one billable result. A PDF is made once per URL, from the first device in your list.

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

Desktop is 1440x900, tablet 820x1180 and mobile 390x844 (the mobile and tablet presets use a touch device and a mobile Chrome user agent). Pick several to get one image per device.

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

Capture the whole scrollable page instead of only the first screen. The page is scrolled first so lazy-loaded images appear. Images are limited to 16,384 device pixels in height.

## `removeCookieBanners` (type: `boolean`):

Clicks the reject or dismiss button of well-known consent tools and hides cookie banners, consent pop-ups and their dark overlays before the capture. Works for common consent platforms and most standard banners, not for every site.

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

CSS selectors of elements to hide before the capture, for example a chat widget (#intercom-container) or a sticky ad (.ad-banner). One selector per line.

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

Capture only this element, for example #main-chart or article. Applies to PNG and JPEG; a PDF always contains the whole page. If no element matches, the row gets status failed and is not charged.

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

Ask the page for its dark color scheme (prefers-color-scheme: dark). Only sites that support a dark theme change their look.

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

Navigation event to wait for. Load waits for images and styles, DOM content loaded is faster, network idle waits until the page stops fetching.

## `waitMs` (type: `integer`):

Pause after the page has loaded, before the capture. Useful for animations and late widgets.

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

Wait until this element exists in the page before the capture. If it does not show up in time, the row gets status failed and is not charged.

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

Maximum time for the page to load. A URL that does not load in time gets status failed and is not charged.

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

Quality of JPEG files, 1 to 100. Lower values make smaller files.

## `pdfFormat` (type: `string`):

Paper size of PDF files.

## `pdfLandscape` (type: `boolean`):

Print PDFs in landscape orientation.

## `pdfPrintStyles` (type: `boolean`):

Off: the PDF looks like the page on screen. On: the page's print stylesheet is used, which often hides menus and backgrounds.

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

Overrides the width of every device preset. Leave empty to use the presets.

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

Overrides the height of every device preset. Leave empty to use the presets.

## `captureErrorPages` (type: `boolean`):

Off: pages that answer with an HTTP error (404, 500 and similar) or show a bot wall are reported as failed or blocked and are free. On: error pages are captured and charged like any other page.

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

How many pages are captured at the same time. 2 is safe with 2048 MB of memory. Use 1 with 1024 MB, or raise memory to 4096 MB before using 4 or more with very long pages.

## Actor input object example

```json
{
  "urls": [
    "https://example.com",
    "https://example.org",
    "https://www.wikipedia.org"
  ],
  "formats": [
    "png"
  ],
  "devices": [
    "desktop"
  ],
  "fullPage": true,
  "removeCookieBanners": true,
  "darkMode": false,
  "waitUntil": "load",
  "waitMs": 1000,
  "timeoutSecs": 30,
  "jpegQuality": 80,
  "pdfFormat": "A4",
  "pdfLandscape": false,
  "pdfPrintStyles": false,
  "captureErrorPages": false,
  "maxConcurrency": 2
}
```

# Actor output Schema

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

One row per URL, device and format with the public file link, size, HTTP status and status (ok, blocked, failed, rejected)

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

The PNG, JPEG and PDF files in the key-value store

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

Files delivered, blocked, failed and rejected pages, and the reason the run stopped

# 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://example.com",
        "https://example.org",
        "https://www.wikipedia.org"
    ],
    "formats": [
        "png"
    ],
    "devices": [
        "desktop"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("atesen-software/website-screenshot-pdf-api").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://example.com",
        "https://example.org",
        "https://www.wikipedia.org",
    ],
    "formats": ["png"],
    "devices": ["desktop"],
}

# Run the Actor and wait for it to finish
run = client.actor("atesen-software/website-screenshot-pdf-api").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://example.com",
    "https://example.org",
    "https://www.wikipedia.org"
  ],
  "formats": [
    "png"
  ],
  "devices": [
    "desktop"
  ]
}' |
apify call atesen-software/website-screenshot-pdf-api --silent --output-dataset

```

## MCP server setup

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

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/npNRTOGbKe1OSpKlQ/builds/k1ucOOIhMSnhGeQs0/openapi.json
