# Website Screenshot & PDF: Full Page, Mobile, Dark Mode (`wisekit/website-screenshot`) Actor

Screenshot any list of URLs as PNG, JPEG or WebP, full page or viewport, on desktop, tablet, mobile or a custom size, with optional PDF, dark mode and cookie banners hidden. $2 per 1,000 screenshots plus $0.002 per run; URLs that fail, are blocked or never load are free.

- **URL**: https://apify.com/wisekit/website-screenshot.md
- **Developed by:** [Wisekit](https://apify.com/wisekit) (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

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/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: Full Page, Mobile, Dark Mode

Screenshot a list of web pages as PNG, JPEG or WebP, full page or viewport, on desktop, tablet, mobile or any size, for **$2 per 1,000 screenshots** ($0.002 each), plus $0.002 per PDF if you want one and a $0.002 start fee per run (at the default 1 GB of memory). Failed, blocked and timed-out URLs are free.
Want to see the output first? Turn on **Demo** in Options: six fictional sample rows and a sample image, no website opened, only the $0.002 start fee.

> **Capture pages you are allowed to capture.** This Actor opens public web pages the way a normal browser does, with an honest User-Agent. It never solves CAPTCHAs, never bypasses bot checks, logins or paywalls, and never captures local or private-network addresses. Pages that answer with a bot check we recognise come back as `blocked`, free.

### What it does

You give it a list of URLs. For each one it opens the page in a real Chromium browser (the open-source base of Chrome), waits until the page has loaded, hides cookie banners, and saves:

- **A screenshot** in PNG, JPEG or WebP: the visible window (viewport) or the **whole page from top to bottom** (full page, up to 16,000 pixels tall).
- **Optionally a PDF** of the page, the way the browser prints it (A4 or Letter, backgrounds on).
- **One tidy row per URL** with the link to the image and PDF, the final URL after redirects, the HTTP status, the page title, the image size in pixels and bytes, how long the page took to load, and a one-line `summary`.

Options you can set:

- **Device presets**: desktop (1440x900), tablet (820x1180 at 2x pixel density, touch) and mobile (390x844 at 2x, touch), or a custom width and height.
- **Dark mode**: the page is told the visitor prefers a dark theme, so sites with one show it.
- **Cookie banners hidden** (best effort): banners of about 20 common consent tools (OneTrust, Cookiebot, Usercentrics, Didomi, Quantcast, TrustArc and others) are hidden with CSS. Nothing is clicked or accepted.
- **Hide your own elements**: CSS selectors of chat widgets, pop-ups or ads to hide before the capture.
- **Waiting**: wait for `load`, `domcontentloaded` or `networkidle`, wait for a CSS selector to appear, add a delay for animations, and scroll down first so lazy-loaded images appear.
- **Time limit per URL** (10 to 30 seconds): a slow page never holds up the run. A URL that hasn't started loading in time is free; a page still loading near the limit is captured as it is, with a warning, and charged like any screenshot.

Results land in two tables, **Screenshots** (every URL, with an image preview) and **Failures** (what wasn't captured and why), plus the image and PDF files in the run's key-value store and a `SUMMARY` record with counts per status.

### Who uses it

- **Marketers and agencies** who need before-and-after shots of landing pages, competitor pages or client sites for reports and pitches.
- **QA and web teams** who check how pages look on desktop, tablet and mobile, in light and dark mode, after every release.
- **SEO and compliance teams** who keep a dated visual record of pages (terms, prices, banners, ads). For records, turn off **Hide cookie banners** so the page is captured unchanged; pages are seen from Apify's servers, so location-based content may differ.
- **Ecommerce teams** who archive product and category pages, or watch how a competitor's store page changes over time.
- **Developers and AI agents** who need a page image or PDF in a pipeline through the API or MCP.

### How to use it

1. Paste your URLs into **URLs**, one per line. Bare domains are fine: `example.com` is opened as `https://example.com/`. Duplicates are merged.
2. Choose the **Device**, and turn on **Full page** if you want the whole page instead of the first screen.
3. Optional: pick the **Image format** (PNG, JPEG or WebP), turn on **Also save a PDF** (+$0.002 per PDF) or **Dark mode**.
4. Click **Start**. The two prefilled pages finish in about 10 seconds.
5. Open the **Screenshots** view and click any image, or export the rows as CSV, Excel or JSON. The files themselves are under **Storage > Key-value store** of the run.

New here? Turn on **Demo** first. It shows six fictional rows covering every kind of result (captured, captured while still loading, timeout, bot check, HTTP 404, private address) and a sample image, so you can see the columns before you capture anything. A demo run costs only the start fee.

### Input

| Field | Default | Notes |
|---|---|---|
| `urls` | (none) | Pages to capture, one per line. Up to 500 per run (10 on the Apify free plan). Only public http and https pages. |
| `device` | `desktop` | `desktop` (1440x900), `tablet` (820x1180 at 2x), `mobile` (390x844 at 2x) or `custom`. No extra cost. |
| `width` | `1440` | With `custom` only: window width in CSS pixels, 320 to 3840. No extra cost. |
| `height` | `900` | With `custom` only: window height in CSS pixels, 240 to 2400. No extra cost. |
| `fullPage` | `false` | Capture the whole scrollable page instead of the first screen. Same price. |
| `maxHeight` | `10000` | Full page only: the longest image in CSS pixels, 1,000 to 16,000 (8,000 on tablet and mobile, which have 2x pixel density). Longer pages are cut with a warning. No extra cost. |
| `format` | `png` | `png`, `jpeg` or `webp`. A PNG over 9 MB is saved as JPEG instead, with a warning. No extra cost. |
| `quality` | `80` | 1 to 100, for JPEG and WebP. No extra cost. |
| `saveScreenshot` | `true` | Save an image of each page ($0.002 per image). Turn off to save PDFs only. |
| `savePdf` | `false` | Also save each page as a PDF (+$0.002 per PDF saved). |
| `pdfFormat` | `A4` | `A4` or `Letter`. No extra cost. |
| `darkMode` | `false` | Ask the page for its dark theme (prefers-color-scheme: dark). No extra cost. |
| `hideCookieBanners` | `true` | Hide common cookie and consent banners with CSS (best effort, nothing clicked). No extra cost. |
| `hideSelectors` | (none) | CSS selectors of elements to hide, up to 50. No extra cost. |
| `waitUntil` | `load` | `load`, `domcontentloaded` or `networkidle`. No extra cost. |
| `waitForSelector` | (none) | Wait for this element before the capture. If it never appears, the URL is `selector_not_found`, free. No extra cost. |
| `delaySecs` | `1` | Extra seconds to wait after loading, 0 to 10. No extra cost. |
| `scrollToBottom` | `false` | Full page only: scroll through the page first (at most 6 seconds) so lazy images load. No extra cost. |
| `timeoutSecs` | `30` | The most time one URL can take, 10 to 30 seconds, everything included. No extra cost. |
| `demo` | `false` | Six fictional sample rows and a sample image; no website opened, only the start fee. |

Example input: `{"urls": ["https://example.com", "https://www.wikipedia.org"], "device": "mobile", "fullPage": true, "format": "webp"}`

### Sample output (from the demo, fictional pages)

| url | status | width x height | bytes | summary |
|---|---|---|---|---|
| demo-shop.example | `ok` | 1440x900 | 216 KB | Viewport PNG 1440x900 px (desktop) of "Demo Shop (fictional)". |
| demo-news.example/live | `ok` | 1440x900 | 216 KB | Viewport PNG 1440x900 px (desktop) of "Live news page (fictional)", with a warning: still loading. |
| demo-slow-site.example | `timeout` | | | Not captured: time limit reached (not charged). |
| demo-protected.example | `blocked` | | | Not captured: the site showed a bot check (not bypassed) (not charged). |
| demo-gone.example/old-page | `http_error` | | | Not captured: the site answered with an HTTP error (not charged). |
| 192.168.0.1 | `invalid_url` | | | Not captured: not a public http(s) URL (not charged). |

One full row of a real capture looks like this:

```json
{
  "url": "https://example.com/",
  "finalUrl": "https://example.com/",
  "status": "ok",
  "summary": "Full-page WEBP 780x1688 px (mobile) of \"Example Domain\".",
  "httpStatus": 200,
  "title": "Example Domain",
  "screenshotUrl": "https://api.apify.com/v2/key-value-stores/<STORE_ID>/records/001-example-com.webp",
  "screenshotKey": "001-example-com.webp",
  "pdfUrl": null,
  "format": "webp",
  "device": "mobile",
  "viewportWidth": 390,
  "viewportHeight": 844,
  "fullPage": true,
  "darkMode": false,
  "width": 780,
  "height": 1688,
  "bytes": 14210,
  "loadSeconds": 1.6,
  "takenAt": "2026-11-18T09:30:12.410Z",
  "warnings": [],
  "demo": false
}
```

### What you get per URL

| Field | What it is |
|---|---|
| `status`, `statusLabel`, `summary` | `ok` or why the page wasn't captured, in words, and a one-line summary |
| `url`, `input`, `finalUrl` | The URL opened, what you typed, and where the page ended up after redirects |
| `httpStatus`, `title` | The HTTP status code and the page title |
| `screenshotUrl`, `screenshotKey` | A direct link to the image, and its key in the run's key-value store |
| `pdfUrl`, `pdfKey`, `pdfBytes`, `pdfError` | The same for the PDF, its size, or why it wasn't saved |
| `format`, `width`, `height`, `bytes` | Image format, size in pixels (device pixels: a mobile image is 780 px wide) and file size |
| `device`, `viewportWidth`, `viewportHeight`, `fullPage`, `darkMode` | The settings used for this capture |
| `loadSeconds`, `takenAt` | How long the page took to load, and when the capture was taken (ISO 8601) |
| `message`, `warnings` | Details when something went wrong, or notes such as "the page is 23000 px tall; the image stops at 10000 px (maxHeight)" |
| `retryable` | `true` when running the URL again later may work |
| `demo` | `true` only on the fictional demo rows |

### Pricing

**$0.002 per screenshot** (pay per event `screenshot`), charged only when the image was saved (`ok`).
**$0.002 per PDF** (pay per event `pdf`), only when `savePdf` is on and the PDF was saved.
**$0.002 start fee per run per GB of memory** (Apify's `apify-actor-start` event): $0.002 at the default 1 GB, $0.004 at 2 GB. It pays for starting the browser, so a run of one URL and a run of 500 cost the same to start.

Free: `timeout`, `blocked`, `http_error`, `dns_error`, `selector_not_found`, `error`, `invalid_url`, `excluded_by_request` and the `skipped_*` statuses. Your maximum charge per run is respected, counting URLs still being captured; URLs beyond it come back as `skipped_max_charge`, free.

**Example 1: weekly desktop screenshots of 300 product pages.** 290 pages are captured, 6 time out and 4 answer HTTP 404. You pay 290 × $0.002 = $0.58 plus the $0.002 start fee: **$0.582**. The 10 failures are free.

**Example 2: 50 landing pages, full page on mobile, with a PDF of each.** 48 are captured with a PDF, 2 show a bot check. You pay 48 × $0.002 (screenshots) + 48 × $0.002 (PDFs) + $0.002 = **$0.194**.

#### What the price buys, compared with cheaper options

You can find cheaper screenshot Actors and free browser extensions. Here is what this one does for its price, so you can judge if it is worth it for you:

- You pay only for images that were saved. Time-outs, HTTP errors and pages that don't exist are free. Common bot-check and "access denied" pages are recognised and not charged; if one ever slips through as `ok`, open an issue with the run ID.
- Full page, viewport, three device presets, custom sizes, dark mode, WebP, PDF and cookie-banner hiding are all in the same price. No extra fee for full page.
- Every row tells you what happened in plain words (`summary`, `statusLabel`, `warnings`), ready for a spreadsheet filter or an automation.
- A demo and a per-run maximum charge, so you know the most a run can cost before you start.

If you need one screenshot once, your browser's own screenshot tool is fine. This Actor is for lists you capture again and again.

### How it treats websites

- Pages are opened by headless Chromium with its own User-Agent (on tablet and mobile with an Android platform, so sites serve their mobile layout) plus `WisekitScreenshot/1.0`, which names this Actor. Headless Chromium is not hidden.
- No proxies, no IP rotation, no CAPTCHA solving and no bot-check bypass. Pages that answer with a bot check we recognise (an "access denied" page, a Cloudflare challenge, a store's interstitial) come back as `blocked`, free.
- Video, audio and live connections (websockets, event streams) are not downloaded; a page stops downloading more after 25 MB.
- Cookie banners are only hidden with CSS. Nothing is clicked, so no consent is given on your behalf.
- Requests to local, private-network and cloud metadata addresses are blocked before they are sent, including host names that point to such an address in DNS. A page that is redirected to one, or that turns out to be served from one, is not captured. Those URLs come back as `invalid_url`, free. WebRTC can't open connections, so pages can't reach the local network that way either.
- Sites whose owners asked us not to open them get no request at all and come back as `excluded_by_request`, free (see "For website owners").
- Your files stay in your own Apify storage. We keep no copy; the run log shows counts and statuses only.

Wisekit is not affiliated with Google, the Chromium project, or the consent tools named here (OneTrust, Cookiebot, Usercentrics, Didomi, Quantcast, TrustArc and others).

### For website owners

If you run a website and don't want this Actor to open it, open an issue on the Actor's **Issues** tab with the domain. We add it to the exclusion list, usually within 2 working days, and from then on its URLs come back as `excluded_by_request`, free.

### Status values

`ok`, `timeout`, `http_error`, `blocked`, `dns_error`, `selector_not_found`, `error`, `invalid_url`, `excluded_by_request`, `skipped_max_charge`, `skipped_plan_limit`, `skipped_run_limit`. Only `ok` is charged.

### Capture pages on a schedule

1. Run the Actor once with your URLs and options, then choose **Save as a new task**.
2. In Apify Console go to **Schedules**, create a schedule (for example every Monday at 07:00, cron `0 7 * * 1`) and add the task.
3. Add an integration to the task (email, Slack, Google Drive, Zapier, Make or a webhook) so each finished run sends you the rows with the image links.

Each run keeps its files in its own key-value store, so you build up a dated history of how each page looked. A weekly run of 50 pages costs about 50 × $0.002 + $0.002 = $0.102, about $0.44 a month.

### Use it through the API or MCP

Run it and get the rows back in one call (replace `<YOUR_API_TOKEN>` with your Apify API token):

```bash
curl -X POST "https://api.apify.com/v2/acts/wisekit~website-screenshot/run-sync-get-dataset-items?token=<YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"urls": ["https://example.com"], "fullPage": true, "format": "jpeg"}'
```

Each row's `screenshotUrl` is a direct link to the image. For AI agents (Claude, Cursor and other MCP clients), add Apify's MCP server with this Actor as a tool: `https://mcp.apify.com/?actors=wisekit/website-screenshot`. The input is plain JSON, for example `{"urls":["https://example.com"]}`, and every row has a one-line `summary` an agent can read directly.

### FAQ

**Is it legal to use?** Taking a screenshot of a public web page is a common and generally lawful thing to do, much like opening the page in your own browser. The Actor only opens public pages, does not log in, does not bypass bot checks or paywalls, and identifies itself honestly. What you do with the images is up to you: page content can be protected by copyright, and some sites' terms limit automated access, so use the screenshots for your own monitoring, testing, research or archives rather than republishing other people's content. This is not legal advice; if you are unsure about your use, ask a lawyer.

**Does it follow robots.txt?** No. robots.txt is written for crawlers that find pages by following links. This Actor isn't a crawler: it opens only the exact URLs you list and follows no links. It names itself in the User-Agent and stops at bot checks. If a site's terms forbid automated access, don't list its pages.

**What about personal data?** Pages can show people's names, photos, reviews or comments. If you capture such pages, you decide why the images are taken and how long they are kept, so data-protection laws such as the GDPR or Australia's Privacy Act apply to your use. Capture only what you need, and delete what you no longer need.

**Why is a page `blocked`?** The site answered with a bot check, an "access denied" page or an interstitial that we recognise (some large stores and social networks do this to all automated browsers). We don't try to get around it. The row is free.

**Why does a page look half-loaded?** Some pages keep loading for a long time. When the time limit is near, the Actor captures what has loaded so far and adds a warning to the row; the screenshot is charged, because an image was saved. Try `waitForSelector` with an element you need, a longer `delaySecs`, or `scrollToBottom` for lazy images.

**Can it log in, or set cookies?** No. It captures pages as a first-time visitor sees them.

**Why is my mobile image 780 pixels wide, not 390?** Phones and tablets have 2x pixel density, so the image has the real device pixels and stays sharp. Use `custom` with the width you want if you need 1x.

**How long are the files kept?** They are in the run's default key-value store, kept for as long as your Apify plan keeps run storage. Download or copy the ones you want to keep for longer.
**Who can open the file links?** On a default Apify account, anyone who has a `screenshotUrl` or `pdfUrl` can open it without logging in (checked 18 Nov 2026); the link contains a long random store ID, so it can't be guessed. Treat the links like the files themselves: share them only with people who should see the page, and turn on restricted access to storages in your Apify account settings if you need links to require your token.

**How fast is it?** Two pages are captured in parallel per GB of memory. Five ordinary pages take about 15 seconds at the default 1 GB; heavy full pages take longer. Giving the run 2 GB doubles the pages in parallel (and the start fee is then $0.004).

**What if I'm on the Apify free plan?** Free-plan runs capture up to 10 URLs; the rest come back as `skipped_plan_limit`, free.

### Other Wisekit Actors

- [Website Tech Stack Detector](https://apify.com/wisekit/tech-stack-detector): the CMS, analytics, hosting and other tools a website uses.
- [Domain Lookup: RDAP, Expiry, Registrar & DNS](https://apify.com/wisekit/domain-lookup): registration status, expiry date and registrar for domain lists.
- [Store Qualifier for Shopify Stores](https://apify.com/wisekit/store-qualifier): country, catalogue size and price range of Shopify stores.
- [Price & Stock Monitor for Shopify Stores](https://apify.com/wisekit/product-price-monitor): track products, prices and stock on Shopify stores.
- [Brand Visibility Tracker: ChatGPT, Perplexity, Gemini & Claude](https://apify.com/wisekit/ai-search-visibility-tracker): see whether AI assistants mention your brand.

### Feedback and support

Found a page that captures badly, a cookie banner that isn't hidden, or need a device size? Open an issue on the Actor's **Issues** tab. We read every issue and aim to reply within one working day. Include the URL and the run ID if you can.

### Changelog

- **0.1 (18 Nov 2026)**: first version: PNG, JPEG and WebP screenshots, full page or viewport, desktop, tablet, mobile and custom sizes, optional PDF, dark mode, cookie-banner hiding, wait options, demo mode. Update before publishing: Playwright 1.65.1; host names checked in DNS before every request; WebRTC restricted; the browser runs without Apify tokens in its environment; takedown list (`excluded_by_request`).

# Actor input Schema

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

Pages to capture, one per line: full URLs ("https://example.com/pricing") or bare domains ("example.com", opened as https). Up to 500 per run (10 on the Apify free plan). Duplicates are merged. Only public http and https pages: local, private-network and other addresses come back as invalid_url, free; sites whose owners asked us not to open them come back as excluded_by_request, free. Agent example: {"urls":\["https://example.com"]}.

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

The screen to emulate. desktop: 1440x900. tablet: 820x1180 at 2x pixel density, touch, mobile layout. mobile: 390x844 at 2x pixel density, touch, mobile layout. custom: the width and height below at 1x. No extra cost. Example: "mobile". Default desktop.

## `width` (type: `integer`):

Only with device "custom": the browser window width in CSS pixels, 320 to 3840. No extra cost. Example: 1920. Default 1440.

## `height` (type: `integer`):

Only with device "custom": the browser window height in CSS pixels, 240 to 2400. It is the image height unless "Full page" is on. No extra cost. Example: 1080. Default 900.

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

On: the image shows the whole page from top to bottom, up to "Max full-page height". Off: only what fits in the window (the viewport). Same price either way. Example: true. Default off.

## `maxHeight` (type: `integer`):

Full page only: the longest image, in CSS pixels, 1000 to 16000. Longer pages are cut at this height and the row gets a warning. Tablet and mobile images (2x density) are capped at 8000 CSS pixels (16,000 image pixels). No extra cost. Example: 15000. Default 10000.

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

png (sharp, larger files), jpeg or webp (smaller files; set the quality below). A PNG over 9 MB is saved as JPEG instead, with a warning. No extra cost. Example: "webp". Default png.

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

1 to 100, for jpeg and webp only (ignored for png). Higher is sharper and larger. No extra cost. Example: 90. Default 80.

## `saveScreenshot` (type: `boolean`):

Save an image of each page (event screenshot, $0.002 per image saved). Turn off to save PDFs only. Example: true. Default on.

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

Also save each page as a PDF, the way the browser prints it (print styles, backgrounds on, 10 mm margins). Charged $0.002 per PDF saved (event pdf), on top of the screenshot. PDFs over 9 MB are not saved and not charged. Example: true. Default off.

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

A4 or Letter. Only with "Also save a PDF". No extra cost. Example: "Letter". Default A4.

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

Tell the page the visitor prefers a dark theme (prefers-color-scheme: dark). Sites with a dark theme show it; sites without one look the same. No extra cost. Example: true. Default off.

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

Hide the cookie and consent banners of common consent tools (OneTrust, Cookiebot, Usercentrics, Didomi, Quantcast, TrustArc and others) with CSS before the capture. Nothing is clicked or accepted; banners we don't recognise stay visible (add them to "Hide these elements"). Turn it off for compliance records or archives, so the page is captured unchanged. No extra cost. Example: true. Default on.

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

CSS selectors of elements to hide before the capture, for example chat widgets, pop-ups or ads: "#chat-widget", ".newsletter-popup". Up to 50. No extra cost.

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

When the page counts as loaded. load: the page and its images have loaded (good default). domcontentloaded: as soon as the HTML is ready (fastest). networkidle: no network traffic for half a second (slowest; some pages never go quiet). If the page isn't there in time, what has loaded is captured and the row gets a warning. No extra cost. Default load.

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

Optional. Wait until this element is visible before the capture, for example "#main-chart" or ".product-grid". If it doesn't appear within the time limit, the URL comes back as selector_not_found and is not charged. No extra cost.

## `delaySecs` (type: `number`):

Seconds to wait after the page has loaded, so animations and late content can finish. 0 to 10. No extra cost. Example: 3. Default 1.

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

Full page only: scroll through the page (at most 6 seconds) before the capture, so images that load on scroll appear. No extra cost. Example: true. Default off.

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

The most time one URL can take, everything included (loading, waiting, capture), 10 to 30. A URL whose page has not started loading in time comes back as timeout, free; a page that is still loading is captured as it is, with a warning, and charged. No extra cost. Example: 20. Default 30.

## `demo` (type: `boolean`):

Shows six fictional sample rows (captured, captured while still loading, timeout, bot check, HTTP 404, private address) and a sample image of a fictional page. No website is opened and no screenshot is charged; only the run start fee applies ($0.002 at the default 1 GB). The URLs you entered are ignored. Example: true. Default off.

## Actor input object example

```json
{
  "urls": [
    "https://example.com",
    "https://www.wikipedia.org"
  ],
  "device": "desktop",
  "fullPage": false,
  "maxHeight": 10000,
  "format": "png",
  "quality": 80,
  "saveScreenshot": true,
  "savePdf": false,
  "pdfFormat": "A4",
  "darkMode": false,
  "hideCookieBanners": true,
  "waitUntil": "load",
  "delaySecs": 1,
  "scrollToBottom": false,
  "timeoutSecs": 30,
  "demo": false
}
```

# Actor output Schema

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

One row per URL: image preview and link, PDF link, image size, page title, status and warnings.

## `failures` (type: `string`):

Why each failed URL was not captured (timeout, HTTP error, bot check, DNS, selector) and whether to try again.

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

All images and PDFs of the run, by key (001-example-com.png, 001-example-com.pdf, ...).

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

Counts by status, pages in parallel, memory waits and settings used.

# 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://www.wikipedia.org"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("wisekit/website-screenshot").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://www.wikipedia.org",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("wisekit/website-screenshot").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://www.wikipedia.org"
  ]
}' |
apify call wisekit/website-screenshot --silent --output-dataset

```

## MCP server setup

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

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/Bs30jQ8mXvB8FgNDm/builds/5UI3goE2CcrZ7QVsp/openapi.json
