# Website Screenshot API — Full Page, Mobile & Batch Screenshots (`highbrow_fame/website-screenshot-api`) Actor

Screenshots of any URL: viewport or full page, mobile/desktop, dark mode, element selector, delay, blocking cookie banners; returns PNG/JPEG/WebP links. Unofficial Screenshot API.

- **URL**: https://apify.com/highbrow_fame/website-screenshot-api.md
- **Developed by:** [yestrue](https://apify.com/highbrow_fame) (community)
- **Categories:** Developer tools, Automation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.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

## Website Screenshot API — Full Page, Mobile & Batch Screenshots

Turn any list of URLs into PNG, JPEG or WebP screenshots — first screen or full page, desktop, tablet or mobile, light or dark, with cookie banners hidden. Every image is stored for you and comes back as a link in the dataset, next to the page's final address, title and size. Built for agents, QA, monitoring and content pipelines that need to *see* a page, not just read it.

**Try it in 1 minute:**

1. Press **Start** — the prefilled input captures `https://example.com` and the Wikipedia article on web scraping on a 1280×800 desktop screen.
2. Open the **Output** tab: one row per page with the image preview, its link, width, height and the page title.
3. Price: **$1.50 per 1,000 screenshots.** Pages that cannot be captured (404, timeout, no such element) are free.

**Use it to:**

- Let an AI agent **verify what a page looks like** after a change, a deploy or a scrape.
- Build **link previews and thumbnails** for a directory, newsletter or CMS in bulk.
- **Monitor competitors and landing pages** daily and keep a visual archive.
- **Check responsive layouts** on mobile and tablet without a device lab.
- Capture a **single element** (a pricing table, a chart, a hero section) for a report or a Slack message.

### How it works

A real headless Chromium (Playwright) opens each URL with the device profile you chose, waits until the page has loaded (and for the optional delay), hides common cookie and consent banners with CSS, and takes the shot: first screen, whole page or one element. The image goes to the run's key-value store and the dataset row carries its public link. Pages are processed in parallel, and a page that times out or fails on the network is tried again on a fresh route before it is given up.

Only public pages: there is no login, no captcha solving and no bot-wall circumvention. A page that answers 404 is reported as `NOT_FOUND`; a server error or a timeout as `FAILED` — both free.

A browser run costs more compute than a plain HTTP fetch; the default memory and `Parallel pages` of 3 are tuned for it. Raise the memory in the run options if you raise the parallelism.

### Input

| Field | What it does | Default |
|---|---|---|
| `urls` | Pages to capture, one per line | the two example pages |
| `fullPage` | Whole scrollable page instead of the first screen | `false` |
| `device` | `desktop` 1280×800, `tablet` 768×1024, `mobile` 390×844 (iPhone, 3× scale) | `desktop` |
| `format` | `png`, `jpeg` or `webp` | `png` |
| `delay` | Extra wait after load, up to 15,000 ms | `0` |
| `selector` | CSS selector: capture only the first matching element | — |
| `width`, `height` | Viewport override in pixels (0 keeps the device's) | `0` |
| `darkMode` | Ask the page for its dark colour scheme | `false` |
| `hideCookieBanners` | Hide common consent banners with CSS (best effort) | `true` |
| `waitUntil` | `load`, `domcontentloaded` or `networkidle` | `load` |
| `quality` | JPEG / WebP quality, 1–100 | `80` |
| `timeout` | Page timeout in ms | `30000` |
| `maxConcurrency` | Pages captured at the same time | `3` |
| `proxyConfiguration` | Used only for retries after a network failure | Apify Proxy |

### Output

One record per page:

| Field | What it is |
|---|---|
| `screenshotUrl` | Link to the image in the run's key-value store (public to anyone with the link) |
| `key` | Key of the image in that store |
| `url`, `finalUrl` | The address opened and where it ended up after redirects |
| `title`, `httpStatus` | The page's title and the main document's HTTP status |
| `width`, `height`, `bytes`, `format` | Image size in pixels and bytes, and its format |
| `fullPage`, `device` | How it was captured |
| `status`, `error` | `OK`, or `NOT_FOUND` / `INVALID_INPUT` / `FAILED` with the reason |
| `input`, `scrapedAt` | What you gave, and when the shot was taken |

#### Example

```json
{
  "input": "https://en.wikipedia.org/wiki/Web_scraping",
  "url": "https://en.wikipedia.org/wiki/Web_scraping",
  "finalUrl": "https://en.wikipedia.org/wiki/Web_scraping",
  "title": "Web scraping - Wikipedia",
  "httpStatus": 200,
  "screenshotUrl": "https://api.apify.com/v2/key-value-stores/aBcDeFgHiJkLmNoPq/records/screenshot-2-en.wikipedia.org.png",
  "key": "screenshot-2-en.wikipedia.org.png",
  "width": 1280,
  "height": 800,
  "fullPage": false,
  "device": "desktop",
  "format": "png",
  "bytes": 184233,
  "status": "OK",
  "scrapedAt": "2026-10-19T12:34:56.000Z"
}
```

### Pricing

You are charged **per screenshot delivered** — see the price on this page. Pages that give no image (404, timeout, no matching element, not a web address) are free. A run also uses Apify platform compute; a browser needs more of it than an HTTP fetch, so keep runs batched.

### FAQ

**Is this an official API?** No, it's an unofficial API built on public pages. It opens the same pages your browser would.

**How long do the images stay available?** As long as the run's key-value store exists — 7 days on the free plan, longer on paid plans (see Apify storage retention). Copy the images to your own storage if you need them for good. Run a named task if you want a predictable store.

**Why does my screenshot still show a cookie banner?** Banners are hidden by CSS patterns covering the common consent managers; a custom banner may slip through. Nothing is clicked or accepted. Try a `selector` that targets the content you need, or a small `delay`.

**Can it log in, pass a captcha or get around a bot wall?** No. Public pages only. A page that answers 403 or a challenge is reported as `FAILED` and not charged.

**Can I take screenshots of a page that needs JavaScript?** Yes — it is a real browser. Use `waitUntil: networkidle` or a `delay` for pages that load content late.

**Like it?** A short review on the Store page helps other people find this Actor. Something missing or broken? Tell us on the Issues tab — we read every one.

### Related Actors

- [Website Tech Stack Detector](https://apify.com/highbrow_fame/website-tech-stack) — CMS, frameworks and analytics of any site
- [Domain Checker](https://apify.com/highbrow_fame/domain-whois-dns-ssl) — WHOIS, DNS, SSL and expiry dates in bulk
- [PageSpeed Insights API](https://apify.com/highbrow_fame/pagespeed-api) — Lighthouse scores and Core Web Vitals
- [URL to Markdown API](https://apify.com/highbrow_fame/url-to-markdown-api) — clean Markdown from any URL for LLMs
- [Web Fetch API](https://apify.com/highbrow_fame/web-fetch-api) — Fetch any URL as HTML, text, Markdown or JSON

# Actor input Schema

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

Pages to capture, one per line. Public pages only — no login.

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

Capture the whole scrollable page instead of the first screen.

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

Screen and browser to pretend: desktop (1280×800), tablet (768×1024, touch) or mobile (390×844, iPhone, 3× scale).

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

PNG (lossless), JPEG or WebP (smaller files; see Quality).

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

Wait this long after the page has loaded before capturing — for animations, lazy images or late scripts. Up to 15,000 ms.

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

Optional CSS selector: capture only the first matching element (for example "#pricing" or "main article"). When nothing matches, the record is NOT_FOUND and free.

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

Overrides the device's width. 0 keeps the device default. Up to 4000.

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

Overrides the device's height (the first screen; full-page captures grow past it). 0 keeps the device default. Up to 4000.

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

Ask the page for its dark colour scheme (prefers-color-scheme: dark). Pages without one look the same.

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

Hides common cookie and consent banners (OneTrust, Cookiebot, Quantcast, Didomi, Usercentrics, Osano and generic "cookie"/"consent" containers) with CSS before capturing. Best effort — nothing is clicked or accepted.

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

When the page counts as loaded: load (default), domcontentloaded (faster, before images) or networkidle (slower, after background requests stop).

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

1–100, for JPEG and WebP only (PNG is lossless).

## `timeout` (type: `integer`):

Give up on a page after this long. A page that times out is tried again and, if it keeps failing, reported as FAILED (free).

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

How many pages to capture at the same time. Each one is a browser tab; 3 is a good match for the default memory.

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

Used only to try again after a network error or timeout: the first try goes out directly.

## Actor input object example

```json
{
  "urls": [
    "https://example.com",
    "https://en.wikipedia.org/wiki/Web_scraping"
  ],
  "fullPage": false,
  "device": "desktop",
  "format": "png",
  "delay": 0,
  "width": 0,
  "height": 0,
  "darkMode": false,
  "hideCookieBanners": true,
  "waitUntil": "load",
  "quality": 80,
  "timeout": 30000,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Every result as a JSON record, with a status for each input.

## `resultsCsv` (type: `string`):

The same records as CSV, for a spreadsheet.

# 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://en.wikipedia.org/wiki/Web_scraping"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("highbrow_fame/website-screenshot-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://en.wikipedia.org/wiki/Web_scraping",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("highbrow_fame/website-screenshot-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://en.wikipedia.org/wiki/Web_scraping"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call highbrow_fame/website-screenshot-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,highbrow_fame/website-screenshot-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/YGjVQwPzddLkXEgD5/builds/4Br1A8TgUtQtPqkwz/openapi.json