# Website Screenshot Generator: Full Page, Mobile & PDF (`rjmacarthy/website-screenshot-generator`) Actor

Screenshot any list of URLs in real Chromium: full page, viewport or one element, on desktop, laptop, iPad, iPhone or Android, as PNG, JPEG or PDF. Hides cookie banners, blocks ads, dark mode, custom CSS. Pay per saved file; failed pages are free.

- **URL**: https://apify.com/rjmacarthy/website-screenshot-generator.md
- **Developed by:** [rj](https://apify.com/rjmacarthy) (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 $2.00 / 1,000 screenshot saveds

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 Generator: Full Page, Mobile & PDF

**Website Screenshot Generator** captures screenshots of any list of URLs in a real Chromium browser: the visible viewport, the **full scrollable page** or **one element**, on **desktop, laptop, iPad, iPhone or Android**, as **PNG, JPEG or PDF**. It **hides cookie banners** before the shot, can **block ads and trackers**, supports **dark mode** and **custom CSS**, and scrolls through the page first so lazy-loaded images show up.

Compared with the free Apify screenshot tool, you get device presets with real mobile user agents and pixel density, several devices per URL in one run, cookie-banner removal, element screenshots, PDF export, and a **predictable price per saved file** instead of paying for browser compute. **Pages that fail are free**: you never pay for a 404, a timeout or a blocked page.

### What can this screenshot tool do?

- 🖥️📱 **Device presets.** Desktop 1920×1080, laptop 1366×768, tablet (iPad), mobile (iPhone 15 Pro with Safari user agent and 3× pixel density), Android (Pixel 7) or any custom size. Pick several and every URL is captured on each.
- 📜 **Full page or viewport.** Full-page captures scroll through the page first so lazy-loaded images and sections appear. Endless pages are cut at a height you choose (default 15,000 px).
- 🎯 **Element screenshots.** Give a CSS selector such as `#pricing` or `.hero` and only that element is captured.
- 📄 **PDF export.** A4, Letter, Legal, A3 or Tabloid, portrait or landscape, with backgrounds, using the site's print styles (like Chrome's *Save as PDF*) or the on-screen look. Screenshot and PDF can come from the same page load.
- 🍪 **No cookie banners.** Hides OneTrust, Cookiebot, Didomi, Quantcast, TrustArc, Usercentrics, Sourcepoint, CookieYes, Complianz, iubenda, consentmanager and many more, plus home-made banners, and unlocks scrolling. Nothing is clicked or accepted; real page content is never hidden.
- 🚫 **Ad and tracker blocking (optional).** Blocks ~45 ad, tracking and analytics domains (Google Ads and Tag Manager, Taboola, Outbrain, Criteo, Hotjar...) for cleaner, faster screenshots.
- 🌙 **Dark mode, hidden elements and custom CSS.** Ask the site for its dark theme, remove chat widgets or sticky headers by selector, or inject your own CSS.
- ⏱️ **Wait control.** Wait for *load*, *DOM content loaded* or *network idle*, add an extra delay, or wait until a selector appears.
- 💸 **Pay per file.** $0.002 per screenshot, $0.003 per PDF. Failed captures cost nothing.

### What data do you get?

Every file is saved in the run's key-value store, and the dataset gets one row per file:

| Field | Example | What it is |
|---|---|---|
| `fileUrl` | `https://api.apify.com/v2/key-value-stores/…/records/apify-com_desktop_92a4e22d.png` | Direct download link to the image or PDF |
| `fileKey` | `apify-com_desktop_92a4e22d.png` | Key of the file in the key-value store |
| `url`, `finalUrl` | `https://apify.com/` | Requested URL and the URL after redirects |
| `httpStatus` | `200` | HTTP status of the page |
| `pageTitle` | `Apify: Marketplace of ready-to-run tools for AI` | The page's title |
| `type`, `format` | `screenshot`, `png` | screenshot or pdf; png, jpeg or pdf |
| `device`, `width`, `height`, `deviceScaleFactor` | `mobile`, `393`, `659`, `3` | Device preset and viewport |
| `fullPage`, `selector` | `true`, `null` | Full page / viewport, or the element captured |
| `imageWidth`, `imageHeight`, `pdfPages`, `bytes` | `1179`, `9750`, `null`, `1173478` | Pixel size of the image, PDF page count, file size |
| `note` | `The page is 31000 px tall; captured the top 15000 px…` | Anything you should know about this capture |
| `takenAt` | `2026-11-02T13:29:05.418Z` | When it was captured |
| `error`, `errorCode` | `null` | Why a capture failed (`DNS_ERROR`, `TIMEOUT`, `HTTP_ERROR`, `BLOCKED`…); failed rows are free |

In Apify Console, the **Screenshots** view shows a thumbnail of every image.

### Use cases

- **Website monitoring and visual QA**: schedule daily screenshots of your landing pages on desktop and mobile and spot broken layouts.
- **Competitor tracking**: archive competitors' home, pricing and product pages over time.
- **SEO and marketing reports**: page previews for audits, client reports and slide decks.
- **Compliance and evidence**: timestamped full-page captures and PDFs of terms, prices or ads as they appeared.
- **Link previews and thumbnails** for directories, bookmarking tools, CMSs and newsletters.
- **AI agents and RAG pipelines**: give a vision model a clean, banner-free screenshot of a page.

### How to take website screenshots

1. Click **Try for free** or **Start**.
2. Paste your **URLs**, one per line.
3. Pick one or more **Devices** and choose **Full page**, **Image format** and **Output** (screenshot, PDF or both).
4. Click **Start**. Open the **Screenshots** tab to preview, or download the files from the key-value store or by `fileUrl`.

#### Input examples

Desktop + mobile full-page JPEGs without cookie banners or ads:

```json
{
    "urls": ["https://apify.com", "https://en.wikipedia.org/wiki/Web_scraping"],
    "devices": ["desktop", "mobile"],
    "fullPage": true,
    "format": "jpeg",
    "jpegQuality": 80,
    "hideCookieBanners": true,
    "blockAds": true
}
```

A4 PDFs only:

```json
{
    "urls": ["https://example.com", "https://github.com"],
    "output": "pdf",
    "pdfFormat": "A4",
    "pdfMedia": "print",
    "pdfPrintBackground": true
}
```

One element, on a retina laptop, in dark mode, after a selector appears:

```json
{
    "urls": ["https://github.com"],
    "devices": ["laptop"],
    "deviceScaleFactor": 2,
    "selector": "footer",
    "waitForSelector": "footer",
    "darkMode": true,
    "hideSelectors": ["#intercom-container", ".newsletter-popup"],
    "customCss": "header { position: static !important; }"
}
```

### Output example

Real output of local runs (trimmed): viewport PNGs from the default input, a full-page iPhone JPEG, a PDF and a failed (free) 404. On Apify, `fileUrl` points to the run's key-value store (`STORE_ID` below); in a local run it is a `file://` path.

```json
[
    {
        "id": "screenshot:desktop:60facd80843d",
        "type": "screenshot",
        "url": "https://apify.com/",
        "finalUrl": "https://apify.com/",
        "httpStatus": 200,
        "pageTitle": "Apify: Marketplace of ready-to-run tools for AI",
        "device": "desktop",
        "width": 1920,
        "height": 1080,
        "deviceScaleFactor": 1,
        "fullPage": false,
        "selector": null,
        "format": "png",
        "fileKey": "apify-com_desktop_92a4e22d.png",
        "fileUrl": "https://api.apify.com/v2/key-value-stores/STORE_ID/records/apify-com_desktop_92a4e22d.png",
        "contentType": "image/png",
        "bytes": 163557,
        "imageWidth": 1920,
        "imageHeight": 1080,
        "pdfPages": null,
        "note": null,
        "takenAt": "2026-11-02T13:41:26.383Z",
        "error": null,
        "errorCode": null
    },
    {
        "id": "screenshot:desktop:c4ab6088339c",
        "type": "screenshot",
        "url": "https://example.com/",
        "finalUrl": "https://example.com/",
        "httpStatus": 200,
        "pageTitle": "Example Domain",
        "device": "desktop",
        "width": 1920,
        "height": 1080,
        "deviceScaleFactor": 1,
        "fullPage": false,
        "selector": null,
        "format": "png",
        "fileKey": "example-com_desktop_2b4284be.png",
        "fileUrl": "https://api.apify.com/v2/key-value-stores/STORE_ID/records/example-com_desktop_2b4284be.png",
        "contentType": "image/png",
        "bytes": 78288,
        "imageWidth": 1920,
        "imageHeight": 1080,
        "pdfPages": null,
        "note": null,
        "takenAt": "2026-11-02T13:41:19.304Z",
        "error": null,
        "errorCode": null
    },
    {
        "id": "screenshot:mobile:48d106530261",
        "type": "screenshot",
        "url": "https://en.wikipedia.org/wiki/Web_scraping",
        "finalUrl": "https://en.wikipedia.org/wiki/Web_scraping",
        "httpStatus": 200,
        "pageTitle": "Web scraping - Wikipedia",
        "device": "mobile",
        "width": 393,
        "height": 659,
        "deviceScaleFactor": 3,
        "fullPage": true,
        "selector": null,
        "format": "jpeg",
        "fileKey": "en-wikipedia-org-wiki-web-scraping_mobile_full_96b6dbc9.jpg",
        "fileUrl": "https://api.apify.com/v2/key-value-stores/STORE_ID/records/en-wikipedia-org-wiki-web-scraping_mobile_full_96b6dbc9.jpg",
        "contentType": "image/jpeg",
        "bytes": 1173478,
        "imageWidth": 1179,
        "imageHeight": 9750,
        "pdfPages": null,
        "note": null,
        "takenAt": "2026-11-02T13:29:19.273Z",
        "error": null,
        "errorCode": null
    },
    {
        "id": "pdf:desktop:fdc052f20ec0",
        "type": "pdf",
        "url": "https://en.wikipedia.org/wiki/Web_scraping",
        "finalUrl": "https://en.wikipedia.org/wiki/Web_scraping",
        "httpStatus": 200,
        "pageTitle": "Web scraping - Wikipedia",
        "device": "desktop",
        "width": 1920,
        "height": 1080,
        "deviceScaleFactor": 1,
        "fullPage": null,
        "selector": null,
        "format": "pdf",
        "fileKey": "en-wikipedia-org-wiki-web-scraping_desktop_a1725a00.pdf",
        "fileUrl": "https://api.apify.com/v2/key-value-stores/STORE_ID/records/en-wikipedia-org-wiki-web-scraping_desktop_a1725a00.pdf",
        "contentType": "application/pdf",
        "bytes": 250828,
        "imageWidth": null,
        "imageHeight": null,
        "pdfPages": 9,
        "note": null,
        "takenAt": "2026-11-02T13:29:18.797Z",
        "error": null,
        "errorCode": null
    },
    {
        "id": "screenshot:desktop:1984ad31c57e",
        "type": "screenshot",
        "url": "https://github.com/this-page-does-not-exist-wsg-xyz",
        "finalUrl": null,
        "httpStatus": 404,
        "pageTitle": null,
        "device": "desktop",
        "width": 1920,
        "height": 1080,
        "deviceScaleFactor": 1,
        "fullPage": true,
        "selector": null,
        "format": "jpeg",
        "fileKey": null,
        "fileUrl": null,
        "contentType": null,
        "bytes": null,
        "imageWidth": null,
        "imageHeight": null,
        "pdfPages": null,
        "note": null,
        "takenAt": "2026-11-02T13:29:20.064Z",
        "error": "HTTP 404 Not Found: the page could not be loaded. Turn on \"Capture error pages\" to screenshot it anyway.",
        "errorCode": "HTTP_ERROR"
    }
]
```

### Pricing

This Actor uses **pay-per-event** pricing. You pay only for files that were saved:

| Event | Price | When |
|---|---|---|
| `screenshot` | **$0.002** | per screenshot image saved (each URL × device) |
| `pdf` | **$0.003** | per PDF saved (one per URL) |

Failed captures (DNS errors, timeouts, HTTP 4xx/5xx, missing selectors) are **not charged**. Browser compute is included in the price.

Worked examples:

- 1,000 desktop screenshots ≈ **$2.00**
- 100 URLs on desktop + mobile = 200 screenshots ≈ **$0.40**
- 100 URLs as screenshot + PDF ≈ 100 × $0.002 + 100 × $0.003 = **$0.50**

Set **Maximum cost per run** on the run's options and the Actor stops cleanly when it's reached; it never starts a capture it can't charge for.

### Tips and limits

- **Download links.** `fileUrl` points to the file in the run's key-value store. It works without login as long as the storage is accessible; if your account restricts storage access, the SDK adds a signature to the URL automatically. Files in a run's default storage are kept for your plan's data-retention period (7 days on the free plan), so copy them elsewhere if you need them longer.
- **Very long pages** are cut at *Max full-page height* (default 15,000 px). One file can be at most ~9 MB: a full-page PNG that would be bigger is saved as JPEG instead (the `note` field says so). For long pages on the 3× iPhone preset, use JPEG.
- **Pages behind bot protection** (Cloudflare challenges, "access denied") may fail with HTTP 403 from Apify's datacenter IPs. Try **Apify Proxy** (datacenter) or turn on *Capture error pages* to see what the site shows. Residential proxies are not supported (see the FAQ), so sites that only let residential IPs through can't be captured.
- **Login-only pages** can't be captured: the Actor uses a fresh browser with no cookies.
- **Cookie banners** are hidden, not accepted, so content a site only shows after consent (some embedded videos, maps) may be missing.
- Pages that scroll inside an inner container (some web apps) only show the visible part in full-page mode; use an element selector for the scrolling container instead.
- The browser is Chromium. The iPhone and iPad presets emulate the screen, pixel density, touch and Safari user agent, but the page is still rendered by Chromium, not WebKit.
- Up to 4 pages load in parallel (about one per 512 MB of memory). The default 2 GB is right for most runs; give 4 GB+ for many full-page captures on high-density devices.

### FAQ

**Is it legal to take screenshots of websites?**
Capturing publicly available pages is generally fine, but you are responsible for how you use the images: respect copyright, trademarks, the site's terms and privacy law (e.g. GDPR) when you store or publish them. The Actor only opens public pages with no login, doesn't accept cookie consent on your behalf, and doesn't collect personal data.

**Do I need a proxy?**
No, most sites work without one. Turn on Apify Proxy (datacenter) for sites that rate-limit Apify's servers or show different content per country. Your own proxy URLs work too.

**Can I use residential proxies?**
No, only Apify datacenter proxy (or your own proxy URLs). The price per screenshot includes all platform costs, and a real browser downloads several MB per page (images, scripts, fonts). Through residential proxy that traffic would cost more than the screenshot itself, so the price could not stay this low. If you select the Residential group, the run logs a warning and uses Apify datacenter proxy instead.

**Am I charged when a page fails?**
No. Failed captures appear in the dataset with an `error` and are free.

**Can I get the image itself instead of a URL?**
Yes: download it from the key-value store (Storage tab), use `fileUrl`, or read the record by `fileKey` through the API.

**Why do the iPhone screenshots look sharper and bigger?**
The mobile preset uses 3× pixel density like a real iPhone (393 CSS px wide → 1179 px image). Set *Pixel density* to 1 for smaller files.

**Can I capture a page after clicking something or logging in?**
No, this Actor captures pages as they load. Use *Wait for selector*, *Extra delay*, *Hide elements* and *Custom CSS* to prepare the view.

### Integrations

- **API**: start runs and fetch results from any language with the [Apify API](https://docs.apify.com/api/v2) or the JavaScript/Python clients. Each item's `fileUrl` is a direct download link.
- **Make, Zapier, n8n**: use the Apify app/node to run the Actor and pass the `fileUrl`s on (Slack, Google Drive, email, Airtable…).
- **MCP / AI agents**: available through the Apify MCP server, so agents can capture a page and look at it.
- **Schedules and webhooks**: run it daily for monitoring and get notified when a run finishes.

### Changelog

- **0.1** (November 2026): first release. Device presets (desktop, laptop, iPad, iPhone, Android, custom), full page/viewport/element screenshots, PNG/JPEG/PDF, cookie-banner hiding, ad blocking, dark mode, hidden elements, custom CSS, wait strategies, lazy-load scrolling, pay per saved file. Apify Proxy is datacenter only (a Residential group falls back to datacenter with a warning).

### Ready-to-run examples

- [Screenshot competitor homepages on desktop and mobile](https://apify.com/rjmacarthy/website-screenshot-generator/examples/competitor-homepage-screenshots)
- [Convert web pages to PDF in bulk](https://apify.com/rjmacarthy/website-screenshot-generator/examples/save-web-pages-as-pdf)

### More scrapers by the same developer

- [Apple App Store Scraper: Apps, Search & Reviews](https://apify.com/rjmacarthy/app-store-scraper)
- [Bing Search Scraper: Organic Results, Ads & Related Searches](https://apify.com/rjmacarthy/bing-search-scraper)
- [Domain WHOIS Lookup - Bulk RDAP, Expiry, DNS & Availability](https://apify.com/rjmacarthy/domain-whois-lookup)
- [ESPN Scraper - Scores, Odds, Standings & Tennis](https://apify.com/rjmacarthy/espn-scraper)
- [Google Ads Transparency Scraper](https://apify.com/rjmacarthy/google-ads-transparency-scraper)
- [Google Play Scraper: Apps, Search & Reviews](https://apify.com/rjmacarthy/google-play-scraper)

Browse all my Actors on [my Apify Store profile](https://apify.com/rjmacarthy).

# Actor input Schema

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

Web pages to capture, one per line, e.g. https://apify.com. Bare domains like example.com get https:// added. Duplicates are removed.

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

Capture every URL on each of these devices (one screenshot per URL per device). Desktop 1920x1080, Laptop 1366x768, Tablet = iPad (810x1080, 2x), Mobile = iPhone 15 Pro (393x659, 3x, Safari user agent), Android = Pixel 7 (412x839), Custom = the width and height below.

## `customWidth` (type: `integer`):

Viewport width in CSS pixels for the "Custom size" device.

## `customHeight` (type: `integer`):

Viewport height in CSS pixels for the "Custom size" device (the visible area; full-page captures extend below it).

## `deviceScaleFactor` (type: `integer`):

Device pixel ratio. 0 = the device's own (1 for desktop/laptop/custom, 2 for iPad, 3 for iPhone). Use 2 for sharp "retina" desktop screenshots; higher values mean bigger files.

## `output` (type: `string`):

Screenshot image, PDF document, or both. A PDF is made once per URL (with the first device's browser settings), not once per device.

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

Capture the whole scrollable page instead of just the visible viewport. Lazy-loaded images are triggered by scrolling first.

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

PNG is lossless (crisp text, bigger files). JPEG is much smaller, good for long full-page captures.

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

1-100. Only used for JPEG.

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

Optional CSS selector, e.g. #pricing or .hero. If set, only the first visible matching element is captured (Full page is ignored). If nothing matches, that page fails and is not charged.

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

Full-page captures of very long or infinite-scroll pages are cut at this height (CSS pixels) to keep files reasonable.

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

Paper size for PDF output.

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

Landscape instead of portrait pages.

## `pdfPrintBackground` (type: `boolean`):

Include background colours and images, like the page looks on screen.

## `pdfMedia` (type: `string`):

"Print" uses the site's print stylesheet, like Chrome's Save as PDF. "Screen" renders the page the way it looks in the browser.

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

When the page counts as loaded. "Load" suits most sites. "Network idle" waits until nothing has loaded for 0.5 s (max 15 s extra), useful for heavy JavaScript apps. "DOM content loaded" is fastest. If the page never gets there, it is captured anyway once the timeout runs out.

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

Wait this long after the page has loaded, e.g. for animations or charts to finish. 0 = no delay.

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

Optional CSS selector to wait for before capturing (up to 15 s), e.g. .product-grid. If it never appears, that page fails and is not charged.

## `scrollToLoadLazyContent` (type: `boolean`):

Before full-page screenshots and PDFs, scroll through the page (max 10 s) so lazy-loaded images and sections appear.

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

How long to wait for a page to load before giving up (or capturing what's there).

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

Hide cookie/consent pop-ups (OneTrust, Cookiebot, Didomi, Quantcast, TrustArc, Usercentrics, Sourcepoint, CookieYes and many more, plus home-made banners) and unlock page scrolling. Nothing is clicked or accepted.

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

Block requests to ~45 common ad, tracking and analytics domains (Google Ads/Tag Manager, Taboola, Outbrain, Criteo, Hotjar, ...). Cleaner and faster screenshots; rarely, a site depends on one of them.

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

CSS selectors of elements to remove before capture, e.g. chat widgets or sticky headers: #intercom-container, .newsletter-popup

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

Tell the site the browser prefers a dark colour scheme (prefers-color-scheme: dark). Only sites that support dark mode change.

## `customCss` (type: `string`):

CSS injected into every page before capture, e.g. body { font-size: 18px !important; }

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

By default a page that returns an HTTP error (404, 500, 403...) is reported as failed and not charged. Turn this on to screenshot whatever the server shows instead (charged like any screenshot).

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

Retry a page this many times on timeouts, network errors, HTTP 429 or 5xx. Not-found, DNS and certificate errors are not retried.

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

Upper limit on pages loaded at the same time. The Actor also scales this down to about one page per 512 MB of memory.

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

Only capture the first this many URLs from the list (a safety limit). 0 = no limit.

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

Not needed for most sites. Enable Apify Proxy if a site blocks Apify's servers (HTTP 403/429) or shows a different country's version. Datacenter proxy only: residential proxies are not supported (a rendered page downloads several MB, which residential traffic would make cost more than the screenshot); if you pick the Residential group, the Actor uses Apify datacenter proxy instead. Your own proxy URLs also work.

## Actor input object example

```json
{
  "urls": [
    "https://apify.com",
    "https://example.com"
  ],
  "devices": [
    "desktop"
  ],
  "customWidth": 1280,
  "customHeight": 800,
  "deviceScaleFactor": 0,
  "output": "screenshot",
  "fullPage": false,
  "format": "png",
  "jpegQuality": 80,
  "maxFullPageHeight": 15000,
  "pdfFormat": "A4",
  "pdfLandscape": false,
  "pdfPrintBackground": true,
  "pdfMedia": "print",
  "waitUntil": "load",
  "delayMs": 0,
  "scrollToLoadLazyContent": true,
  "navigationTimeoutSecs": 30,
  "hideCookieBanners": true,
  "blockAds": false,
  "darkMode": false,
  "captureErrorPages": false,
  "maxRetries": 1,
  "maxConcurrency": 4,
  "maxUrls": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

One item per file with a preview, page title, device and download URL.

## `details` (type: `string`):

Every field: download URL, key, sizes, image dimensions, PDF pages, notes and errors.

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

All saved PNG/JPEG/PDF files in the run's default key-value store.

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

Per-URL status, counts, request statistics and warnings.

# 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",
        "https://example.com"
    ],
    "devices": [
        "desktop"
    ],
    "fullPage": false,
    "format": "png"
};

// Run the Actor and wait for it to finish
const run = await client.actor("rjmacarthy/website-screenshot-generator").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",
        "https://example.com",
    ],
    "devices": ["desktop"],
    "fullPage": False,
    "format": "png",
}

# Run the Actor and wait for it to finish
run = client.actor("rjmacarthy/website-screenshot-generator").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",
    "https://example.com"
  ],
  "devices": [
    "desktop"
  ],
  "fullPage": false,
  "format": "png"
}' |
apify call rjmacarthy/website-screenshot-generator --silent --output-dataset

```

## MCP server setup

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

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/NQT6eiHuli8mHd84D/builds/cOabMzFpKgJovUXII/openapi.json