# Website Screenshot API: $2/1K, Full Page & PDF, No Login (`conserving_celerytop/website-screenshot-api`) Actor

$2 per 1,000 captures. Take full-page screenshots or PDFs of any list of URLs: PNG, JPEG, WebP or PDF, desktop, laptop, tablet or mobile, one element by CSS selector, lazy images loaded, cookie banners hidden. Each file gets a public link. Failed URLs are free.

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

## Pricing

from $2.00 / 1,000 captures

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, PDF, Bulk URLs

Website Screenshot API takes a full-page screenshot or a PDF of every URL you give it. Paste one URL or a few thousand, pick PNG, JPEG, WebP or PDF, pick a desktop, laptop, tablet or mobile screen, and get one file per page with a public link you can open, embed or download. You can capture the whole page, only the visible screen, or a single element by CSS selector. It costs $2 per 1,000 captures, and URLs that fail are free.

### What can this website screenshot tool do?

- **Full-page screenshots** of long pages, with lazy-loaded images scrolled into view first.
- **PNG, JPEG, WebP and PDF** output. JPEG and WebP take a quality setting; PDF takes paper size, orientation and backgrounds.
- **Device presets**: Desktop 1920x1080, Laptop 1366x768, Tablet 820x1180 at 2x, Mobile 390x844 at 3x, or a custom width, height and pixel density.
- **Element screenshots**: capture only `#pricing`, `.hero` or any CSS selector.
- **Hide elements** such as cookie banners, chat widgets and pop-ups before the capture.
- **Wait options**: a delay, "wait for element", or wait until the network is quiet.
- **Dark mode** for sites that support `prefers-color-scheme: dark`.
- **Bulk URLs** with several pages in parallel and one dataset row per URL.

Typical uses: visual archives of competitor pages, social preview images, QA checks after a deploy, PDF copies of articles or invoices you are allowed to keep, and screenshots for reports and pitch decks.

### How to take website screenshots in bulk

1. Open the Actor and paste your URLs into **URLs**, one per line. A bare domain such as `example.com` works too.
2. Choose a **Format** (PNG, JPEG, WebP or PDF) and a **Device**.
3. Keep **Full page** on for the whole page, or turn it off for the visible screen only. To capture one part of the page, enter a CSS selector in **Element**.
4. Optional: list cookie banners or pop-ups in **Hide elements**, and raise **Delay** for pages that animate in.
5. Click **Start**. When the run ends, open the **Screenshots** tab to see previews, or download the dataset as JSON, CSV or Excel. Every row has a `screenshotUrl` link to the file.

You can also call the Actor from the Apify API, the Apify client for JavaScript or Python, Make, Zapier or n8n, and read the dataset when the run finishes.

### How much does the Website Screenshot API cost?

The price is pay per event: **$2.00 per 1,000 captures** ($0.002 per file). A capture is one file saved: one PNG, JPEG, WebP or PDF. Rows for URLs that could not be captured (invalid URL, robots.txt does not allow the page, timeout, bot check, missing element) are free. A page that answers 404 or 500 still gives a file of what it shows, so it counts as a capture. Platform usage is included in the price.

Worked example: 5,000 product pages as full-page PNG. 4,900 load fine and 100 time out. You pay 4,900 x $0.002 = **$9.80**. The 100 timeouts cost nothing.

On the Apify free plan, the monthly free credit covers about 2,500 captures. You can set a spending limit on any run; the Actor stops opening new pages when the next capture would pass it.

### Input example

```json
{
    "urls": ["https://example.com", "https://www.wikipedia.org"],
    "format": "png",
    "fullPage": true,
    "device": "mobile",
    "hideSelectors": ["#onetrust-banner-sdk"],
    "delaySeconds": 1
}
```

### Output example

Each URL gives one dataset row. The file itself sits in the run's key-value store, and `screenshotUrl` links to it.

```json
{
    "url": "https://example.com/",
    "finalUrl": "https://example.com/",
    "status": "ok",
    "httpStatus": 200,
    "pageTitle": "Example Domain",
    "format": "png",
    "device": "mobile",
    "width": 1170,
    "height": 2532,
    "pageHeight": 844,
    "truncated": false,
    "fileSizeBytes": 61234,
    "screenshotUrl": "https://api.apify.com/v2/key-value-stores/STORE_ID/records/00001-example.com.png",
    "fileKey": "00001-example.com.png",
    "capturedAt": "2026-09-27T09:00:00.000Z",
    "warnings": [],
    "error": null,
    "charged": true
}
```

A failed URL looks the same with `status` set to the reason (for example `timeout` or `robots_disallowed`), `error` in plain words, no file and `charged: false`. A `STATS` record in the key-value store sums up the run.

### Related Actors

- [Website Tech Stack Detector](https://apify.com/store?search=website%20tech%20stack%20detector) finds the CMS, analytics and hosting behind a list of websites.
- For page text instead of images, search the Apify Store for "website content crawler" or "HTML to Markdown".

### FAQ

#### Is it legal to take screenshots of websites?

Capturing a public web page is generally allowed, but what you do with the image can be limited by copyright, the site's terms and privacy law. Capture pages you have a right to use, and do not collect personal data with this tool. The Actor opens only public pages, sends no login or cookies, follows each site's robots.txt, identifies itself with a contact address in its User-Agent, and stops on a site that answers 401, 403 or 429 or shows a bot check. It never tries to solve a CAPTCHA.

#### What are the limits?

Full-page images stop at 16,000 pixels in height (5,333 CSS pixels on the 3x mobile preset); taller pages are cut there and marked `truncated`. Each page gets up to 120 seconds to load. Pages behind a login, a paywall or a bot check are not captured. Addresses on private networks are refused.

#### Why is my screenshot blank or missing content?

Some pages draw their content after the load event. Raise **Delay**, set **Wait for element** to something that appears last, or choose "Network quiet" in **Page ready when**. Cookie banners that cover the page can be removed with **Hide elements**.

#### How do I get more speed?

Give the run more memory and raise **Parallel pages** (default 4, up to 10). Memory sets a cap of one page per 512 MB above the first 512 MB: 1 GB opens one page at a time, 2 GB opens three, and 4 GB opens seven when **Parallel pages** is 7 or more.

#### Something does not work

Open an issue on the Issues tab with the run link and the URL. We aim to answer within a day.

# Actor input Schema

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

Enter the pages to capture, one per line, as a full URL (https://example.com/pricing) or a domain (example.com). Each URL gives one file.

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

Choose the file type: PNG (sharp, lossless), JPEG or WebP (smaller files) or PDF (printable document).

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

Capture the whole scrolling page, top to bottom. Turn off to capture only the visible screen area.

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

Choose the screen: Desktop 1920x1080, Laptop 1366x768, Tablet 820x1180 at 2x, Mobile 390x844 at 3x, or Custom to set the size yourself.

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

Capture one element only, for example #pricing or .hero. The first match is used. Leave empty to capture the page.

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

CSS selectors of elements to hide before the capture, for example cookie banners, chat widgets or pop-ups (#onetrust-banner-sdk, .cookie-notice).

## `delaySeconds` (type: `integer`):

Wait this long after the page loads, so animations and late content settle.

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

Choose when the page counts as loaded: after the load event, after the HTML is parsed, or when the network has been quiet for half a second.

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

Wait until this CSS selector is visible before the capture, for example #chart. If it never shows, the page is captured anyway with a warning.

## `scrollPage` (type: `boolean`):

Scroll through the page before a full-page capture or PDF, so images that load on scroll appear.

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

Ask the page for its dark color scheme (prefers-color-scheme: dark).

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

Image quality from 1 to 100 for JPEG and WebP. Higher means sharper and larger files.

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

Stop full-page captures at this height in CSS pixels. The final image is at most 16,000 pixels tall, so the mobile preset (3x) stops at 5,333.

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

Screen width in CSS pixels when Device is Custom.

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

Screen height in CSS pixels when Device is Custom.

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

Device pixel ratio: 1, 2 or 3 (2 gives a retina image twice as wide). Leave empty to use the device preset.

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

Paper size for PDF files.

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

Print PDF pages in landscape orientation.

## `printBackground` (type: `boolean`):

Include background colors and images in PDF files.

## `timeoutSeconds` (type: `integer`):

Give each page this long to load. A page that shows content by then is captured as it is.

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

Open up to this many pages at once. Memory also sets a cap: one page per 512 MB above the first 512 MB (1 GB gives 1, 2 GB gives 3, 4 GB gives 7).

## Actor input object example

```json
{
  "urls": [
    "https://example.com",
    "https://www.wikipedia.org"
  ],
  "format": "png",
  "fullPage": true,
  "device": "desktop",
  "delaySeconds": 1,
  "waitUntil": "load",
  "scrollPage": true,
  "darkMode": false,
  "quality": 80,
  "maxHeight": 15000,
  "viewportWidth": 1280,
  "viewportHeight": 800,
  "pdfFormat": "A4",
  "pdfLandscape": false,
  "printBackground": true,
  "timeoutSeconds": 30,
  "maxConcurrency": 4
}
```

# Actor output Schema

## `overview` (type: `string`):

screenshotUrl, url, status, pageTitle, format, width, height, fileSizeBytes and error.

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

Every field per URL, including finalUrl, httpStatus, warnings and charged.

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

The PNG, JPEG, WebP and PDF files, one key per URL.

## `stats` (type: `string`):

JSON with URLs captured, statuses, retries, charges, parallel pages and duration.

# 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"
    ],
    "format": "png"
};

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

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

```

## MCP server setup

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