# Website Screenshots: Full Page, Pay Only for Success (`fairtools/website-screenshots`) Actor

Full-page website screenshots in PNG, JPEG or WebP. Tall pages are stitched instead of cut off (PNG and JPEG). You pay only for saved images. Failed or blocked URLs are free.

- **URL**: https://apify.com/fairtools/website-screenshots.md
- **Developed by:** [Harendra Singh](https://apify.com/fairtools) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$6.00 / 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 Screenshots

Give it a list of web addresses. It opens each one in a real Chrome browser, takes a picture of the page, and gives you the image files plus a table saying what happened to each address.

You pay for saved screenshots only. A page that fails, is blocked or times out costs you nothing.

### Why this one

**Full-page shots that are not cut off.** Many pages only load pictures and sections when you scroll to them. Before a full-page shot, this Actor scrolls from top to bottom, waits for the page to stop growing and for images to finish loading, then captures. Very tall pages (PNG and JPEG) are captured in pieces and stitched into one image, up to 60,000 px tall.

**You do not pay for failures.** One `screenshot` charge is made per image, and only after the image has been saved. Every address gets a row in the results with a clear status, so you can see exactly what you were charged for.

**It says so when a site blocks it.** If a site shows a bot check or CAPTCHA, the row says `blocked`. The Actor does not try to get around it and does not charge you.

### What to expect

In our tests on 100 well-known public sites, about 3 in 4 were saved. Almost all of the rest were sites that block automated browsers: mainly large news sites, big online shops and review sites. If most of your addresses are of that kind, this is not the right tool.

Typical time is 15 to 20 seconds per page. Very tall pages can take one to three minutes.

### Input

| Field | What it means | Default |
|---|---|---|
| `urls` | List of addresses. Each must start with `http://` or `https://`. | required |
| `fullPage` | On: the whole page, top to bottom. Off: only the visible window. | on |
| `width` | Browser window width in pixels (320 to 3840). | 1280 |
| `height` | Browser window height in pixels (200 to 2160). For full-page shots the image is as tall as the page. | 800 |
| `format` | `png`, `jpeg` or `webp`. | `png` |
| `quality` | 1 to 100, for JPEG and WebP only. | 80 |
| `waitSeconds` | Extra seconds to wait after the page loads (0 to 30), for pages that animate in. | 0 |
| `maxConcurrency` | Pages captured at the same time. Leave empty to let the Actor decide. | automatic |

Example:

```json
{
  "urls": ["https://apify.com", "https://en.wikipedia.org/wiki/Web_scraping"],
  "fullPage": true,
  "format": "jpeg"
}
```

### Output

**Image files** are saved in the run's key-value store, named like `screenshot-0001-apify-com.png`.

**One row per address** is saved in the run's dataset:

| Field | Meaning |
|---|---|
| `url` | The address you gave. |
| `status` | See the table below. |
| `imageUrl` | Link to the image, or empty if none was saved. |
| `seconds` | How long this address took. |
| `httpStatus` | The site's response code, when there was one. |
| `widthPx`, `heightPx`, `bytes` | Size of the saved image. |
| `pageHeightPx` | How tall the page really was (full-page mode). |
| `truncated` | True if the page was taller than the image limit and the image was cut there. |
| `charged` | True only if a `screenshot` charge was made for this row. |
| `error` | Plain-language reason when the status is not `success`, or a note when the image was cut. |

| Status | Meaning | Charged? |
|---|---|---|
| `success` | Image saved. | Yes |
| `blocked` | The site showed a bot check or CAPTCHA, or answered 401, 403, 407 or 429. | No |
| `http_error` | The site answered with another error code, such as 404 or 500. | No |
| `refused` | The address is not allowed (see Safety rules). | No |
| `failed` | The page did not load or took too long. | No |
| `skipped_budget` | The spending limit you set for the run was reached first. | No |

If no screenshot at all is saved, the run is marked as failed.

### Image height limits

| Format | Tallest image |
|---|---|
| PNG, JPEG | 60,000 px at widths up to 1,333 px. Wider windows lower the limit (about 41,600 px at 1920 wide). |
| WebP | 16,000 px. The WebP format cannot hold a taller image. Use PNG or JPEG for very long pages. |

A page taller than the limit is cut there. The row is marked `truncated` and `pageHeightPx` shows the real height.

### Safety rules

- **No logins.** It does not sign in anywhere, and refuses addresses that contain a username or password.
- **No CAPTCHA bypass.** Blocked pages are reported as `blocked` and not charged.
- **No local or private addresses.** It refuses `localhost`, private network ranges, cloud metadata addresses and names that resolve to any of these, including when a public page redirects to one.

### Limits you should know about

- **Sites that block automated browsers will not work.** Results can also differ from run to run on the same site.
- **A saved image is not a guarantee the page looks right.** Some sites answer normally but hold back part of their content from automated browsers. Check images from sites you care about.
- **Very tall, heavy pages can time out.** Each address has a 150-second limit. A few long news and feed pages exceeded it in testing.
- **Stitched images can differ slightly from a single shot.** A floating header appears once at the top and is removed from the rest; side panels that follow you down the page stay at their starting position.
- **Only the page itself is scrolled.** Sites that scroll inside an inner panel (some web apps and dashboards) are captured as the visible window only.
- **Endless feeds stop** after 30 seconds of scrolling or at the height limit.
- **Cookie banners and pop-ups are captured as they appear.** Nothing is clicked or hidden.
- **Error pages are not captured.** A 404 page gives an `http_error` row and no image.
- **Location and language** are those of the server running the Actor. You cannot choose a country.
- **Memory:** the default of 4 GB is what was tested. With less, heavy pages can crash the browser.

### Tips

- Use JPEG or WebP for smaller files; PNG images of long pages are often several megabytes.
- If a page fades or animates in, set `waitSeconds` to 2 or 3.
- Set a maximum cost for the run if you want a hard spending cap. The Actor stops taking screenshots when it is reached and marks the rest `skipped_budget`.

# Actor input Schema

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

Web pages to capture. Each must start with http:// or https://. Localhost and private network addresses are refused.

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

On: capture the whole page from top to bottom, scrolling first so lazy-loaded content appears. Off: capture only the visible area (width x height).

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

Browser window width in pixels.

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

Browser window height in pixels. For full-page shots this is only the window size used while loading; the image is as tall as the page.

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

PNG is lossless and largest. JPEG and WebP are smaller.

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

1 to 100. Ignored for PNG.

## `waitSeconds` (type: `integer`):

Optional extra time to wait after the page has loaded, for pages that animate in or load content late.

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

Leave empty to let the Actor choose from the memory it was given.

## Actor input object example

```json
{
  "urls": [
    "https://apify.com"
  ],
  "fullPage": true,
  "width": 1280,
  "height": 800,
  "format": "png",
  "quality": 80,
  "waitSeconds": 0
}
```

# Actor output Schema

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

Status, image link and seconds taken for every input URL.

## `images` (type: `string`):

The screenshots, stored 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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fairtools/website-screenshots").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"] }

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

```

## MCP server setup

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

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/zC6St4T6kfhKgV9UZ/builds/eHWBWaOC3NGOLESdY/openapi.json
