# Website Screenshot API: Full Page, Mobile, No Cookie Banners (`localscreenshot/website-screenshot-api`) Actor

Take screenshots of any public web page with Localscreenshot : full page, desktop or phone, PNG, JPEG or WebP, with cookie banners and ads hidden. Free to try without an account, 3 pages per run. With a free localscreenshot key: up to 100 pages per run, PDF, and screenshots from 227 countries.

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

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-usage

## 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

Take screenshots of public web pages: full page or just the visible part, on a desktop, a tablet or a phone screen, with cookie banners and ads hidden. The images land in the key-value store of the run and each page gets one row in the dataset.

**Free to try, no account needed.** Run it as it is and the first 3 pages of your list are captured. With the key of a free [localscreenshot](https://localscreenshot.com/signup?utm_source=apify\&utm_medium=actor\&utm_campaign=website-screenshot) account (50 free credits a month, no card) you get up to 100 pages per run, screenshots as seen from another country, and PDF.

The screenshots are taken by localscreenshot, a screenshot API built for AI agents and scripts. This Actor is the same service, packaged for Apify: no browser runs inside it, so a run is short and light.

### What you can do with it

- Capture a list of pages in one run, for a report, an archive or a visual check.
- Get a clean picture: cookie banners and ads can be hidden, and a page can be asked for its dark theme.
- Capture a page as a phone, a tablet or a desktop sees it: 11 devices.
- Save a page as PNG, JPEG or WebP, or as a PDF with your own key.
- See a page as a visitor from another country sees it, with your own key. The result tells you the country the page was actually loaded from.
- Schedule it, chain it with other Actors, or call it from the Apify API.

### Without a key, and with your own

| | Without an API key | With your own free key |
|---|---|---|
| Pages per run | 3 | 100 |
| Full page, device, PNG, JPEG, WebP | Yes | Yes |
| Hide cookie banners, block ads, dark mode | Yes | Yes |
| Country | No | Yes, 227 countries |
| PDF | No | Yes |
| Extra wait before the screenshot | No | Yes |
| What it uses | A small allowance shared by everyone who tries the Actor. It has a limit per day, and a limit per site per day. | Your own credits: 50 free every month, no card. |

Without a key, the pages after the third are listed in the dataset with what to do to capture them, and a run that asks for a country or a PDF captures nothing and says why. When the shared allowance of the day is used up, the run ends normally and the dataset says so: add your own free key and run it again.

To get a key: [create a free account](https://localscreenshot.com/signup?utm_source=apify\&utm_medium=actor\&utm_campaign=website-screenshot), open **Connect** in the dashboard, copy the key and paste it in the **API key** field of the Actor. The field is stored encrypted.

### Input

| Field | What it does |
|---|---|
| **Pages to capture** (`urls`) | One web address per line, starting with `http://` or `https://`. Up to 100 in one run; the first 3 are captured without a key. |
| **API key** (`apiKey`) | Optional. The key of your localscreenshot account. Stored encrypted. |
| **Full page** (`fullPage`) | Capture the whole scrollable page instead of the visible part. |
| **Device** (`device`) | `desktop`, `desktop_hd`, `laptop`, `ipad`, `ipad_pro`, `ipad_mini`, `iphone_15`, `iphone_15_pro_max`, `iphone_se`, `pixel_8`, `galaxy_s24`. |
| **File format** (`format`) | `png`, `jpeg`, `webp`, or `pdf` with your own key. |
| **Country** (`country`) | A two-letter code such as `BR`, `DE` or `JP`. Needs your own key. Leave it empty to load the page from the server. |
| **Hide cookie banners** (`blockCookieBanners`) | Removes most cookie banners. A banner the filters do not know stays in the picture. |
| **Block ads** (`blockAds`) | Blocks ads on the page. |
| **Dark mode** (`darkMode`) | Asks the page for its dark theme, when it has one. |
| **Extra wait** (`delayMs`) | Waits up to 5,000 ms after the page has loaded, before the screenshot. Applied with your own key. |

Works without a key:

```json
{
    "urls": ["https://example.com", "https://www.wikipedia.org"],
    "fullPage": true,
    "device": "iphone_15",
    "format": "jpeg",
    "blockCookieBanners": true
}
```

With your own key:

```json
{
    "urls": ["https://example.com", "https://www.wikipedia.org"],
    "apiKey": "YOUR_LOCALSCREENSHOT_KEY",
    "country": "BR",
    "format": "pdf"
}
```

### Output

Each page gives one dataset row. The image itself is in the key-value store of the run, under the name in `imageKey`; `imageUrl` opens it.

```json
{
    "url": "https://example.com",
    "status": "succeeded",
    "takenAt": "2026-10-13T10:00:00.000Z",
    "finalUrl": "https://example.com/",
    "pageStatus": 200,
    "title": "Example Domain",
    "imageKey": "screenshot-001-example.com.png",
    "imageUrl": "https://api.apify.com/v2/key-value-stores/STORE_ID/records/screenshot-001-example.com.png",
    "contentType": "image/png",
    "width": 1440,
    "height": 900,
    "bytes": 18364,
    "note": "Taken without an API key (3 pages per run). A free account gives 50 free credits a month, no card, with country and PDF.",
    "link": "https://localscreenshot.com/signup?utm_source=apify&utm_medium=actor&utm_campaign=website-screenshot"
}
```

The `status` of a row is one of:

- `succeeded`: the image is stored.
- `failed`: the page could not be captured. `errorCode` and `errorMessage` say why. One failed page does not stop the others.
- `skipped`: the page was not tried because it needs your own key (`errorCode` is `own_key_required`).
- `summary`: the last row of a run without a key. It says how many pages were captured, how many were left aside and why, and what a free account gives. The same facts are in its `_captured`, `_failed`, `_leftAside`, `_why`, `_signup`, `_pricing`, `_mcp` and `_cli` fields. A run with your own key has no summary row.

Every row has a `note` and a `link`: what to do next, and where. With your own key, a row also has `creditsCharged` and `creditsRemaining`, and with a country `countryRequested` and `countryObserved`.

If you read the dataset from code, keep the rows whose `status` is `succeeded`.

### What it costs

The Actor is free. Without a key, the screenshots are on us, within the limits above. With your own key, a screenshot uses 1 credit of your localscreenshot account, or 2 when you choose a country, and a screenshot that fails is not charged. A free account gets 50 credits every month, with no card; plans and credit packs are on the [pricing page](https://localscreenshot.com/pricing?utm_source=apify\&utm_medium=actor\&utm_campaign=website-screenshot). On the Apify side you pay the platform usage of the run, which is small because the Actor does not run a browser.

### What it does not do

- It does not sign in to websites, and it does not capture pages behind a login.
- It does not solve CAPTCHAs and does not get past paywalls. Some sites block automated browsers: the page then comes back as failed, with the reason.
- It captures public pages only. Addresses of private networks are refused.
- It does not click or type on the page.

### Limits and fair use

Up to 100 pages in one run, two at a time. A free localscreenshot account can send 10 requests a minute; the Actor waits and tries again when it is told to slow down.

Screenshots taken without a key are kept on our side for 24 hours at most; the copy in your run's key-value store follows your Apify retention. The service follows the localscreenshot [acceptable use policy](https://localscreenshot.com/acceptable-use) and [terms](https://localscreenshot.com/terms). To report a misuse, or to ask that your site is not captured: hello@localscreenshot.com.

### More than this Actor

The same service is available as a REST API, an [MCP server](https://localscreenshot.com/mcp?utm_source=apify\&utm_medium=actor\&utm_campaign=website-screenshot) for Claude, Cursor and other AI tools, and a [command line client](https://localscreenshot.com/cli?utm_source=apify\&utm_medium=actor\&utm_campaign=website-screenshot) (`npx localscreenshot https://example.com`).

Questions: hello@localscreenshot.com.

# Actor input Schema

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

One web address per line, starting with http:// or https://. Public pages only. Without an API key, the first 3 pages of a run are captured. With your own free key, up to 100.

## `apiKey` (type: `string`):

Leave empty to try the Actor: 3 pages per run, no country, no PDF. With the key of a free localscreenshot account (50 free credits a month, no card) you get up to 100 pages per run, any country and PDF, on your own credits. Create the account at https://localscreenshot.com/signup?utm_source=apify\&utm_medium=actor\&utm_campaign=website-screenshot then copy the key from the dashboard, under Connect. Stored encrypted.

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

Capture the whole scrollable page instead of the visible part.

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

Capture as this device: screen size, pixel density and mobile browser.

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

PDF saves the whole page as a document, and needs your own API key.

## `country` (type: `string`):

Load the page from this country: a two-letter code such as BR, DE or JP. Leave empty to load it from the server. Needs your own API key. A screenshot from a chosen country costs more credits, and the result tells you the country that was actually observed.

## `blockCookieBanners` (type: `boolean`):

Removes most cookie banners. A banner the filters do not know stays in the picture.

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

Block ads on the page.

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

Ask the page for its dark theme, when it has one.

## `delayMs` (type: `integer`):

Wait this long after the page has loaded, before the screenshot. Applied with your own API key only.

## Actor input object example

```json
{
  "urls": [
    "https://example.com"
  ],
  "fullPage": false,
  "device": "desktop",
  "format": "png",
  "blockCookieBanners": false,
  "blockAds": false,
  "darkMode": false,
  "delayMs": 0
}
```

# Actor output Schema

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

One row per page asked for: image link, size, page title and HTTP status, or the reason it was not captured.

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

The image files of this run, named screenshot-001-<site>.png and so on.

# 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"
    ]
};

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

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

```

## MCP server setup

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