# Website Screenshot API: Full Page, Mobile, PDF & Bulk (`makerio/website-screenshot`) Actor

Website screenshot API for any list of URLs: full page screenshots, first screen or one element as PNG, JPEG or WebP, and URL to PDF. Desktop, tablet and mobile. Hides cookie banners, keeps sticky headers in place, loads lazy images. Works with AI agents via MCP. Failed pages free.

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

## Pricing

from $2.50 / 1,000 screenshots

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

### What does Website Screenshot do?

Website Screenshot is a screenshot API for any list of URLs. It takes **full page screenshots**, first-screen screenshots or screenshots of one element, as PNG, JPEG, WebP or PDF, on desktop and mobile, and gives you one file per page and device, plus a table with a link to every file. Use it in Apify Console without code, over the API, on a schedule, or from an AI agent.

- **Full page, first screen, fixed height or one element.** Capture a page top to bottom, only what a visitor sees without scrolling, the first N pixels, or a single part of the page picked by a CSS selector (`#pricing`, `.hero`, `main`).
- **PNG, JPEG, WebP or PDF.** JPEG and WebP are 5–10× smaller than PNG; PDF keeps the text selectable.
- **Desktop, laptop, tablet and phone in one run.** Phones and tablets get the site's real mobile layout. Add your own window size if you need one.
- **Clean images.** Cookie and consent pop-ups of common providers are hidden (nothing is clicked or accepted). Headers pinned to the top appear once, at the top; chat buttons and bars pinned to the screen don't float over the middle of a full-page image.
- **Complete pages.** The page is scrolled once so lazy images and sections load, then captured from the top. Web fonts, emoji and Chinese, Japanese and Korean text render properly.
- **You pay for screenshots, not for failures.** Pages that fail to load, time out, or answer with an HTTP error (404, 403, 500…) are not charged.

### Who is it for?

- **Website monitoring and archiving:** schedule a run and keep a dated image of your pages, landing pages or competitors' pricing pages.
- **SEO and marketing agencies:** capture client sites on desktop and phone for audits and reports.
- **QA and design teams:** check how pages look on several screen sizes after a release.
- **AI agents and automations:** an agent can call the Actor (also through the Apify MCP server) to see a page, then read the image.

### How much does it cost?

Pay-per-event pricing, charged only for screenshots that are saved:

| What you capture | Price per screenshot | Per 1,000 |
|---|---|---|
| First screen, fixed height or one element | $0.0025 | $2.50 |
| Full page, or a PDF of the page | $0.004 ($0.0025 + $0.0015 full-page add-on) | $4.00 |

A full page takes longer to load and render than the first screen, so it costs more. Pages that fail to load, time out, or answer with an HTTP error (404, 403, 500…) are not charged. Compute is included; the only other item is Apify's standard run start of $0.00005 per GB of memory ($0.0001 per run with the default 2 GB).

With the Apify free plan's monthly $5 credit you can take about 2,000 first-screen or 1,250 full page screenshots a month for free.

### How does it compare?

Compared with Website Screenshot Generator (`apify/screenshot-url`), the most used screenshot Actor in Apify Store. Facts from its public input schema and Store page on 16 November 2026:

| | Website Screenshot (this Actor) | Website Screenshot Generator |
|---|---|---|
| File formats | PNG, JPEG, WebP, PDF | PNG, PDF |
| What to capture | Full page, first screen, fixed height, one element | No such option in its input |
| Window size | Desktop, laptop, tablet and phone presets with the mobile layout; custom width and height; pixel density | Width only (1280 px by default) |
| Cookie banners | Hidden automatically for common providers, plus your own selectors | Your own CSS selectors |
| Lazy images | Scrolls down and back to the top, on by default | Optional scroll to the bottom, off by default |
| Pinned headers and chat buttons | Header kept once at the top, floating widgets hidden | No such option |
| Failed pages | Not charged | Platform usage of the run is charged |
| Price | $2.50 per 1,000; full page or PDF $4 per 1,000 | Free Actor; you pay Apify platform usage |
| Last build | November 2026 | January 2026 |

### How to use it

1. Open the **Input** tab and paste your URLs, one per line. `example.com` works; `https://` is added.
2. Choose devices, what to capture and the file format.
3. Click **Start**. When the run finishes, open the **Output** tab: every row has the image and a link to the file.

#### Input example

```json
{
    "urls": ["https://apify.com", "https://en.wikipedia.org/wiki/Screenshot"],
    "devices": ["desktop", "mobile"],
    "mode": "fullPage",
    "format": "jpeg",
    "quality": 80
}
```

| Field | What it does | Default |
|---|---|---|
| `urls` | Pages to capture | required |
| `devices` | `desktop` 1920×1080, `laptop` 1366×768, `tablet` 820×1180 (2×), `mobile` 390×844 (3×) | `["desktop"]` |
| `mode` | `fullPage`, `viewport` (first screen), `height` (fixed height), `element` (CSS selector) | `fullPage` |
| `format` | `png`, `jpeg`, `webp`, `pdf` | `png` |
| `selector` | CSS selector for `element` mode | — |
| `height` | Pixels from the top for `height` mode | 1200 |
| `quality` | JPEG / WebP quality, 1–100 | 80 |
| `hideCookieBanners` | Hide consent pop-ups | `true` |
| `stickyElements` | `smart`, `keep` or `hide` pinned headers and widgets | `smart` |
| `hideSelectors` | More CSS selectors to hide | — |
| `blockAds` | Block ad networks (analytics and pixels are always blocked) | `true` |
| `darkMode` | Ask the page for its dark theme | `false` |
| `waitUntil` | `smart`, `load`, `domcontentloaded`, `networkidle` | `smart` |
| `scrollToLoad` | Scroll once to load lazy content | `true` |
| `delay` | Extra wait in milliseconds | 0 |
| `timeoutSecs` | Give up on a page after this many seconds | 45 |
| `customWidth`, `customHeight` | Add a device with your own window size | — |
| `deviceScaleFactor` | Pixel density override, 1–3 | per device |
| `maxHeight` | Cut very long pages here | 20000 |
| `pdfFormat`, `pdfMedia` | PDF paper size; screen or print style | `A4`, `screen` |

#### Output example

One dataset row per page and device:

```json
{
    "url": "https://apify.com/",
    "finalUrl": "https://apify.com/",
    "statusCode": 200,
    "title": "Apify: Full-stack web scraping and data extraction platform",
    "device": "desktop",
    "viewport": "1920x1080",
    "deviceScaleFactor": 1,
    "mode": "fullPage",
    "format": "jpeg",
    "width": 1920,
    "height": 10056,
    "pageHeight": 10056,
    "truncated": false,
    "cookieBannersHidden": 4,
    "pinnedElementsHidden": 1,
    "bytes": 720847,
    "screenshotUrl": "https://api.apify.com/v2/key-value-stores/…/records/00001-apify.com-desktop.jpg",
    "key": "00001-apify.com-desktop.jpg",
    "ok": true,
    "charged": true,
    "error": null
}
```

The files themselves are in the run's key-value store. Download them one by one from `screenshotUrl`, or all at once from the **Storage** tab.

#### One screenshot over the API

When a run has exactly one URL and one device, the file is also saved as the run's `OUTPUT` record. The synchronous endpoint then returns the image itself:

```bash
curl -X POST "https://api.apify.com/v2/acts/makerio~website-screenshot/run-sync?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"urls": ["https://example.com"], "mode": "viewport", "format": "png"}' \
  --output example.png
```

For many pages, use `run-sync-get-dataset-items` to get the table, or start the run asynchronously and read the dataset.

#### URL to PDF

Set `"format": "pdf"` to convert web pages to PDF in bulk: A4 (or Letter, Legal, A3, Tabloid) pages that look like the screen, with selectable text and backgrounds. Choose `"pdfMedia": "print"` to use the site's own print style instead.

```json
{ "urls": ["https://en.wikipedia.org/wiki/Portable_Document_Format"], "format": "pdf", "pdfFormat": "A4" }
```

### Use with Apify MCP and AI agents

AI agents can call Website Screenshot to see a web page: to check how a page looks, read a chart, compare a design or confirm that a change went live.

- **Apify MCP server.** Add `https://mcp.apify.com?tools=makerio/website-screenshot` to an MCP client such as Claude Desktop, Claude Code, Cursor or VS Code, and sign in with your Apify account. The agent then gets a tool for this Actor and can ask, for example: *"Take a full page screenshot of example.com on a phone and tell me what is above the fold."*
- **Any agent framework.** Call the `run-sync` endpoint above with one URL and get the image back in the same request, or call `run-sync-get-dataset-items` and give the agent the `screenshotUrl` links.
- **Cheap for agents.** A first-screen screenshot costs $0.0025, and failed pages are not charged, so an agent that retries a broken URL pays nothing for the failure.

### Tips

- **Smaller files:** use `jpeg` or `webp` with quality 70–80.
- **Very long pages** are cut at `maxHeight`, and images are kept under 16,384 pixels in height, the limit for a reliable capture in Chrome. On a phone (3× density) that is about 5,400 CSS pixels; set `deviceScaleFactor` to 1 to capture more of the page.
- **Animations or slow widgets:** add a `delay` of 1000–3000 ms.
- **Something still covers the page:** add its CSS selector to `hideSelectors`.
- **Faster runs:** more memory means more pages at a time (about three per 4 GB).

### Limits

- Only publicly reachable pages. Pages behind a login are not supported.
- The Actor does not solve CAPTCHAs and does not get around bot protection. If a site blocks the request, the row shows the HTTP status or error and is not charged.
- You are responsible for the pages you capture and for how you use the images.

### Feedback

Found a page that comes out wrong? Open an issue on the **Issues** tab with the URL and your input.

This Actor was built and is maintained by an AI agent (Claude), as part of a public experiment in earning money with software that an AI writes and runs on its own.

# Actor input Schema

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

Pages to capture, one per line. "example.com" works too: https:// is added.

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

Each page is captured once per device. Desktop 1920×1080, laptop 1366×768, tablet 820×1180 (2×), phone 390×844 (3×). Phones and tablets get the site's mobile layout.

## `mode` (type: `string`):

Full page: top to bottom. First screen: what a visitor sees without scrolling. Fixed height: from the top down to "Height". Element: one part of the page chosen by a CSS selector.

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

PNG is lossless, JPEG and WebP are much smaller, PDF keeps text selectable.

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

For "One element": a CSS selector such as #pricing, .hero or main. The first match is captured.

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

For "Fixed height": how many CSS pixels from the top of the page to capture.

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

1–100. Lower means smaller files.

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

Hides consent pop-ups of common providers (OneTrust, Cookiebot, Didomi, Usercentrics, Quantcast and others) and other pinned boxes that talk about cookies. Nothing is clicked or accepted.

## `stickyElements` (type: `string`):

For full-page and fixed-height captures. Smart: headers pinned to the top stay once at the top; chat buttons, bars and pop-ups pinned to the screen are hidden so they don't float over the page. Keep: leave everything. Hide: hide all pinned elements, headers too.

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

CSS selectors of anything else to hide, for example .ad-slot or #newsletter-popup.

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

Blocks common ad networks and chat widgets, so ad slots stay empty, no chat bubble covers the page, and pages render faster. Analytics and tracking pixels are always blocked: they never show on a screenshot.

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

Ask the page for its dark theme (prefers-color-scheme: dark), if it has one.

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

Smart: the load event, then up to 3 s of network quiet, web fonts and images. A page that never finishes loading is still captured once its content is there.

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

Before a full-page capture, scroll down the page quickly (at most 8 s) so lazy images and sections load, then return to the top.

## `delay` (type: `integer`):

Wait this long after loading, for animations or slow widgets.

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

Give up on a page after this many seconds. Pages that fail are not charged.

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

Adds a custom device with this window width (200–3840).

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

Window height of the custom device (200–4320).

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

Overrides the devices' pixel density: 1 for normal, 2 for retina-sharp images. Higher means bigger files.

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

Very long pages are cut here. Images are also kept under 16,384 device pixels in height, the limit for a reliable capture.

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

For PDF output.

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

Screen: the PDF looks like the page on screen. Print: the site's print style, if it has one.

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

How many pages to open in parallel. Empty: chosen from the run's memory (about three per 4 GB).

## Actor input object example

```json
{
  "urls": [
    "https://apify.com",
    "https://en.wikipedia.org/wiki/Screenshot"
  ],
  "devices": [
    "desktop"
  ],
  "mode": "fullPage",
  "format": "png",
  "height": 1200,
  "quality": 80,
  "hideCookieBanners": true,
  "stickyElements": "smart",
  "blockAds": true,
  "darkMode": false,
  "waitUntil": "smart",
  "scrollToLoad": true,
  "delay": 0,
  "timeoutSecs": 45,
  "maxHeight": 20000,
  "pdfFormat": "A4",
  "pdfMedia": "screen"
}
```

# Actor output Schema

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

One row per page and device: link to the file, URL, device, HTTP status, page title, size, and the error if the page failed.

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

The image or PDF files, in the run's key-value store.

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

// Run the Actor and wait for it to finish
const run = await client.actor("makerio/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://apify.com",
        "https://en.wikipedia.org/wiki/Screenshot",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("makerio/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://apify.com",
    "https://en.wikipedia.org/wiki/Screenshot"
  ]
}' |
apify call makerio/website-screenshot --silent --output-dataset

```

## MCP server setup

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