# Website Screenshot API: Full Page, Mobile, Element & PDF (`subtleasianmerch/website-screenshot-api`) Actor

Capture full-page website screenshots and PDFs of any URL at desktop, tablet and phone sizes, from Console or the API. Cookie banners hidden, ads blocked, lazy content loaded. From $2.50 per 1,000; failed and blocked pages are free.

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

## Pricing

from $2.50 / 1,000 screenshot (visible screen or element)s

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, Element & PDF

Get **full-page screenshots and PDFs of any public web page**, at desktop, laptop, tablet and phone sizes, from Apify Console or one API call. **You pay only for the screenshots you get:** failed, blocked and error pages are free.

- 📸 **Full page, visible screen or one element,** as PNG, JPEG or PDF.
- 📱 **Five device sizes or your own:** desktop, laptop, iPad, iPhone and Pixel in one run.
- 🧹 **Clean pages:** cookie banners hidden, 76 ad and tracking services blocked, lazy content loaded.
- 🌙 **Dark mode and 2× or 3× density,** with emoji and Chinese, Japanese and Korean text rendered.
- 🔌 **One API call, one JSON row per capture,** with a link to each file.
- 💸 **From $2.50 per 1,000 screenshots.** Failed, blocked and error pages are free.

**Try it:** the input comes pre-filled with two pages. Click **Start** to get full-page desktop screenshots of both, for $0.015, then add your own pages.

### What you get

One image or PDF per page and device size, saved in the run's storage, and one row of details for each.

| Option | Choices |
|---|---|
| What to capture | The full page, the visible screen, or one element by CSS selector (such as `#pricing`) |
| Format | PNG, JPEG (quality 1–100, default 80) or PDF (A4, Letter, Legal or A3) |
| Device sizes | Desktop 1920×1080, laptop 1366×768, iPad Pro 11, iPhone 17, Pixel 9, or a custom size from 200 to 3,840 px wide |
| Pixel density | Each device's own (1× on desktop, about 3× on phones), or 1×, 2× or 3× |
| Colour scheme | Light, or dark on sites that support it |
| Page clean-up | Cookie banners from over 20 consent tools hidden, never accepted; ads and trackers blocked; your own selectors hidden |
| Endless pages | Cut at 15,000 CSS px by default (up to 30,000), with `truncated` marking cut pages |

**Every row** also has the final address after redirects, the HTTP status and the page title. It adds the image size, file size, load time and whether it was charged.

**Pick several sizes and each page is captured at each one.** 10 URLs at 3 sizes give 30 screenshots.

**Built for reliable runs:**

- a fresh browser session for every capture, so cookies never carry over;
- retries for pages that time out or are busy (HTTP 429 or 5xx);
- emoji and Chinese, Japanese and Korean fonts installed, so text shows no empty boxes;
- the log and the run summary show the time each step took, which explains slow pages.

### Who it's for

- **SEO and marketing teams:** capture landing pages and pricing pages, yours and other companies', on a schedule at desktop and phone sizes.
- **Web developers and QA testers:** check one layout at five device sizes in a single run, in light and dark mode.
- **Agencies and designers:** send clients full-page captures or PDFs of their sites, or crop one section, such as a pricing table.
- **Compliance, legal and research teams:** keep dated records of how pages looked, with the capture time and HTTP status on every row.
- **App builders:** call it from the API to make page thumbnails and link previews.

### How much does it cost?

| Event | Price each | Per 1,000 |
|---|---|---|
| Visible-screen or element screenshot | $0.0025 | $2.50 |
| Full-page screenshot | $0.005 | $5.00 |
| PDF | $0.006 | $6.00 |
| Run start | $0.005 | |

**Worked examples:**

- **1,000 visible-screen thumbnails:** 1,000 × $0.0025 = $2.50, plus $0.005 for the run.
- **1,000 full pages on desktop:** 1,000 × $0.005 = $5.00, plus $0.005. If a quarter of the sites block cloud servers, you pay for 750: $3.755.
- **20 URLs a day at desktop and mobile, full page:** 40 × $0.005 = $0.20, plus $0.005: $0.205 a day, or $6.15 over 30 days.

**Free:** pages that fail to load, return an HTTP error (404, 500…) or show a bot check. They are listed with the reason and `"charged": false`.

**Element captures** are charged at the screenshot rate, even with "Full page" on. Full pages and PDFs cost more because the whole page is rendered, and PDFs are large files to store.

**Spending limit:** set a maximum cost per run, and the run stops cleanly before the capture that would go over it. The run summary counts the pages it skipped as `skippedAtSpendingLimit`.

### How to use it

1. **Add your web pages,** one URL per line, up to 10,000. `https://` is added when missing, and repeated URLs are captured once.
2. **Choose device sizes and what to capture:** full page or visible screen, PNG, JPEG or PDF, or one element by CSS selector.
3. **Keep the page preparation defaults,** or hide more elements, wait for an element, or add a delay.
4. **Click Start.** Set a maximum cost per run first if you want a cap. The status line shows progress, such as "12 of 40 done: 11 captured, 1 failed".
5. **Open the Screenshots view** for thumbnails, or export the rows as JSON, CSV or Excel. Each row's `screenshotUrl` links to its file.

The **All details** view adds the final URL, HTTP status, page height, file size, timing and whether each row was charged.

### Example input

Full pages of two sites at three sizes, as PNG, with two extra elements hidden. This makes 6 full-page screenshots: $0.03, plus $0.005 for the run.

```json
{
  "urls": ["https://apify.com", "https://en.wikipedia.org/wiki/Web_scraping"],
  "devices": ["desktop", "mobile", "custom"],
  "viewportWidth": 1280,
  "viewportHeight": 800,
  "fullPage": true,
  "format": "png",
  "pixelRatio": "auto",
  "hideCookieBanners": true,
  "blockAds": true,
  "hideSelectors": ["#intercom-container", ".newsletter-popup"],
  "maxHeight": 15000
}
```

One element per page, in dark mode, as a sharp JPEG. This makes 3 element screenshots: $0.0075, plus $0.005 for the run.

```json
{
  "urls": ["https://en.wikipedia.org/wiki/Web_scraping", "https://github.com", "https://news.ycombinator.com"],
  "devices": ["desktop"],
  "selector": "h1, #hnmain",
  "fullPage": false,
  "format": "jpeg",
  "jpegQuality": 85,
  "pixelRatio": "2",
  "colorScheme": "dark",
  "waitUntil": "networkidle",
  "delayMs": 1000
}
```

For PDFs, set `"format": "pdf"` and, if you like, `"pdfPaper": "Letter"`. A PDF always covers the whole page, so it can't be combined with an element selector.

#### All input fields

| Console title | Key | Values (default) |
|---|---|---|
| Web pages | `urls` | Up to 10,000 URLs (required) |
| Device sizes | `devices` | `desktop`, `laptop`, `tablet`, `mobile`, `android`, `custom` (`desktop`) |
| Full page | `fullPage` | `true` or `false` (`true`) |
| Output format | `format` | `png`, `jpeg`, `pdf` (`png`) |
| Only this element (CSS selector) | `selector` | A CSS selector; the first match is captured (empty) |
| JPEG quality | `jpegQuality` | 1 to 100 (80) |
| Pixel density | `pixelRatio` | `auto`, `1`, `2`, `3` (`auto`) |
| Colour scheme | `colorScheme` | `light`, `dark` (`light`) |
| Hide cookie banners | `hideCookieBanners` | `true` or `false` (`true`) |
| Block ads and trackers | `blockAds` | `true` or `false` (`true`) |
| Also hide these elements | `hideSelectors` | A list of CSS selectors (empty) |
| Scroll to load lazy content | `scrollToLoad` | `true` or `false` (`true`); used for full pages and PDFs |
| Wait until | `waitUntil` | `load`, `domcontentloaded`, `networkidle` (`load`) |
| Wait for element (CSS selector) | `waitForSelector` | Waits up to 15 seconds for it to be visible (empty) |
| Extra delay | `delayMs` | 0 to 60,000 ms (0) |
| Maximum page height | `maxHeight` | 500 to 30,000 px (15,000) |
| Custom width | `viewportWidth` | 200 to 3,840 px (1,440); `custom` device only |
| Custom height | `viewportHeight` | 200 to 4,000 px (900); `custom` device only |
| PDF paper size | `pdfPaper` | `A4`, `Letter`, `Legal`, `A3` (`A4`) |
| Capture error pages | `captureErrorPages` | `true` or `false` (`false`); when on, error pages are captured and charged |
| Page load timeout | `navigationTimeoutSecs` | 5 to 180 seconds (45) |
| Retries | `maxRetries` | 0 to 5 (2) |
| Pages at once | `maxConcurrency` | 0 to 20 (0: one page per GB of memory, so 4 at the default 4 GB) |
| Proxy | `proxyConfiguration` | Off by default; Apify's datacenter proxy or your own proxy URLs |

### Example output

One row per page and device. This row is from a test run on Apify (28 October 2026), with the link's signature shortened:

```json
{
  "url": "https://en.wikipedia.org/wiki/Web_scraping",
  "device": "desktop",
  "format": "png",
  "fullPage": true,
  "selector": null,
  "capturedAt": "2026-10-28T19:10:58.130Z",
  "status": "ok",
  "finalUrl": "https://en.wikipedia.org/wiki/Web_scraping",
  "httpStatus": 200,
  "title": "Web scraping - Wikipedia",
  "screenshotUrl": "https://api.apify.com/v2/key-value-stores/…/records/en.wikipedia.org_desktop_cc62473b29.png?signature=…",
  "key": "en.wikipedia.org_desktop_cc62473b29.png",
  "width": 1920,
  "height": 8745,
  "viewportWidth": 1920,
  "viewportHeight": 1080,
  "deviceScaleFactor": 1,
  "pageHeight": 8745,
  "truncated": false,
  "bytes": 2398904,
  "loadMs": 23813,
  "charged": true,
  "error": null
}
```

**The fields:**

- `status`: `ok` or `failed`.
- `screenshotUrl` and `key`: the file's link, and its record name in the run's key-value store.
- `width` and `height`: the image size in pixels, pixel density included. PDF rows leave them empty.
- `viewportWidth`, `viewportHeight` and `deviceScaleFactor`: the screen the page was shown on.
- `pageHeight`: the page's full height in CSS pixels. `truncated` is `true` when the page was cut at the maximum height.
- `finalUrl`: where the page ended up after redirects. `httpStatus` and `title` come from that page.
- `bytes`: the file size. `loadMs`: time from opening the page to finishing the capture.
- `charged`: whether this row was charged.

**Files and links:** each image or PDF is saved in the run's key-value store. Its name is the site, the device and a short code, ending in `.png`, `.jpg` or `.pdf`. The `screenshotUrl` link carries a signature, so it opens without your API token. Share it only with people who should see the file.

**Failed rows** are listed free, with `"status": "failed"`, `"charged": false` and an `error` saying why. This one is from the same test run:

```json
{
  "url": "https://github.com/this-page-does-not-exist-xyz-123",
  "device": "desktop",
  "format": "png",
  "fullPage": true,
  "selector": null,
  "capturedAt": "2026-10-28T19:17:07.932Z",
  "status": "failed",
  "finalUrl": "https://github.com/this-page-does-not-exist-xyz-123",
  "httpStatus": 404,
  "title": "Page not found · GitHub · GitHub",
  "screenshotUrl": null,
  "key": null,
  "width": null,
  "height": null,
  "viewportWidth": null,
  "viewportHeight": null,
  "deviceScaleFactor": null,
  "pageHeight": null,
  "truncated": false,
  "bytes": null,
  "loadMs": null,
  "charged": false,
  "error": "The page returned HTTP 404"
}
```

Other errors you may see:

- `Blocked by bot protection (Cloudflare challenge)`, or another named bot check;
- `Page did not load: …`, with the browser's reason;
- `No element matches "…"`, when the element selector finds nothing;
- `The element "…" did not appear within 15 seconds`, from "Wait for element";
- `The page was too heavy to render in time …`, with a tip to lower "Maximum page height" or use JPEG.

**Run summary:** the `RUN_SUMMARY` record in the key-value store has:

- pages requested, captured and failed, and how many were skipped at the spending limit;
- the average seconds per capture, and per step: opening, loading, checking, scrolling, images, extra waits and capturing;
- seconds spent on failures, total megabytes, pages at once, and the list of failures.

### Integrations

- **Apify API:** start a run and get the rows back in one call. Fetch each file from its `screenshotUrl`.

  ```bash
  curl -X POST "https://api.apify.com/v2/acts/subtleasianmerch~website-screenshot-api/run-sync-get-dataset-items?token=YOUR_TOKEN" \
    -H "Content-Type: application/json" \
    -d '{"urls": ["https://apify.com"], "devices": ["desktop", "mobile"], "fullPage": true, "format": "png"}'
  ```

  The call returns one row per page and device. For long lists, start the run with the `runs` endpoint instead, and read the dataset when it finishes.
- **Schedules:** capture the same pages daily or weekly. Each run gets its own dataset and files, so you keep a dated record.
- **Webhooks, Make, Zapier and n8n:** receive the rows when a run finishes. Each row carries its file link, so the next step can fetch the image.
- **Monitoring:** Apify's monitoring can alert you by email or Slack when a scheduled run fails.

### FAQ

**Is it legal to use?** The Actor captures public pages you choose, the way a browser shows them. It doesn't log in, and it doesn't get past bot checks. Whether you may capture and use a page, for example under its terms or copyright, is your responsibility. This isn't legal advice.

**Why did a page fail?** The row's `error` field says why: an HTTP error, a bot check, a page that didn't load, or an element that wasn't found. Failed rows have `"charged": false`, so you don't pay for them. If every page fails, the run ends as failed, with the first error in its status.

**Which sites can't be captured?**

- **About a quarter of big consumer and news sites block cloud servers.** In a 115-site test on Apify, 85 pages were captured and 27 were refused by bot checks or HTTP 403 or 429. 3 more were meant to fail.
- **No bot-check solving.** The Actor recognises challenge pages from Cloudflare, DataDome, PerimeterX, Imperva, Amazon and DDoS-Guard, and reports them as failed. It doesn't try to get past them.
- **Logged-in pages aren't supported,** and there's no cookies input.
- **Public addresses only.** Private and internal addresses are refused, including redirects to them.

**How do I capture a site that blocks cloud servers?** Turn on "Proxy" with Apify's datacenter proxy (leave the groups empty), or add your own proxy URLs, and keep "Retries" at 2 or more. Each retry uses a new proxy session. In a 20-site test with the datacenter proxy, 16 were captured. Sites that still refuse stay free.

**Can I use residential proxies?** No. A full page loads 2–5 MB, and residential traffic for that would cost more than the screenshot's price. Runs that ask for residential, Unblocker or Google SERP proxies stop before any capture, so nothing is charged.

**How fast is it?** Median times per capture in tests on Apify:

- 30 seconds for a full desktop page, on the 115-site mix;
- 22 seconds for a full phone page;
- 15 seconds for a visible screen, and 15 for a PDF;
- 4 seconds for one element on a simple page.

Pages run 4 at a time by default.

**How big are the files, and how do I make them smaller?** Phone-size full pages averaged 6 MB as PNG in a 20-site test, because phones default to about 3× density. PDFs of 10 big news, shop and company sites averaged about 18 MB, up to 81 MB. Choose JPEG and lower "JPEG quality", or set "Pixel density" to 1×, for much smaller files.

**Can I capture just one part of a page?** Yes. Put a CSS selector in "Only this element", such as `#pricing`. The first matching element is captured, at $2.50 per 1,000.

**The page loads its content late. How do I wait for it?** Set "Wait until" to "Network quiet", or put the content's selector in "Wait for element". "Extra delay" adds up to 60 seconds for animations or slow widgets.

**Why does my screenshot look different from my browser?** Ads and trackers are blocked, cookie banners are hidden, and animations are asked to stop. Turn off "Block ads and trackers" or "Hide cookie banners" to see the page as visitors do. Chat bubbles and pop-ups can be hidden with "Also hide these elements". The browser is set to US English, so sites that follow the browser's language show English.

**What about endless feeds, web apps and very heavy pages?**

- **Endless-scroll pages** (some shop and social feeds) are captured as far as they have loaded. Scrolling stops after 12 seconds or at the height limit.
- **Some web apps scroll inside a container** instead of the whole page. Full-page capture then shows only the visible part, so use an element selector on the scrolling container.
- **Very heavy pages** can time out while rendering. They aren't retried, because they would take as long again. Lower "Maximum page height", or choose JPEG.

**What happens when a run reaches my maximum cost?** It stops cleanly before the capture that would go over the limit. The run summary counts the rest as `skippedAtSpendingLimit`.

### Related Actors

More Actors from the same developer that work well with this one:

| Actor | Use it to |
|---|---|
| [Google Ads Transparency](https://apify.com/subtleasianmerch/google-ads-transparency) | find a competitor's Google ads, then capture the landing pages they point to |
| [Lighthouse Audit](https://apify.com/subtleasianmerch/lighthouse-audit) | score the same pages for speed, accessibility and SEO |
| [Video Frame Extractor](https://apify.com/subtleasianmerch/video-frame-extractor) | take still images from video files, the way this Actor captures pages |

Questions, bugs or ideas? Open an issue on this Actor's **Issues** tab.

# Actor input Schema

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

One URL per line. https:// is added when missing.

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

One screenshot per page for each size you pick. Desktop is 1920×1080, laptop 1366×768, tablet an iPad Pro 11, mobile an iPhone 17 and Android a Pixel 9. Custom uses the width and height below.

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

Capture the whole page from top to bottom. Turn off for just the visible screen.

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

PNG is sharpest, JPEG is smaller, PDF gives a document of the whole page.

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

Capture a single element instead of the page, for example #pricing or .hero. Leave empty for the whole page.

## `jpegQuality` (type: `integer`):

1 to 100. Used only for JPEG.

## `pixelRatio` (type: `string`):

Automatic uses each device's own density: 1× on desktop, about 3× on phones (sharp but large files). Pick 1× for small files on any device, or 2× for sharp desktop (retina) images.

## `colorScheme` (type: `string`):

Dark asks the page for its dark mode, on sites that have one.

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

Hides common cookie-consent banners and unlocks scrolling they block. Nothing is clicked or accepted.

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

Blocks requests to common ad, analytics and tracking services, for clean screenshots without ad slots or ad pop-ups. Turn off to see pages exactly as visitors do, ads included.

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

CSS selectors to hide before capture, such as chat widgets or pop-ups: #intercom-container, .newsletter-popup.

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

Scrolls through the page first so lazy-loaded images and sections appear in full-page captures.

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

When the page counts as loaded. "Network quiet" waits longer and suits pages that load data after opening.

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

Wait until this element is visible before capturing, up to 15 seconds.

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

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

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

Full-page captures stop at this height, so endless pages don't produce enormous images. The output says when a page was cut.

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

Used only with the Custom size device.

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

Used only with the Custom size device.

## `pdfPaper` (type: `string`):

Used only for PDF output.

## `captureErrorPages` (type: `boolean`):

By default, pages answering with an error (404, 500 and so on) are reported as failed and not charged. Turn on to capture and pay for them anyway.

## `navigationTimeoutSecs` (type: `integer`):

How long to wait for a page to start loading before retrying.

## `maxRetries` (type: `integer`):

Extra attempts for pages that time out, are busy (429/5xx) or show a bot check. Each retry uses a new proxy session when a proxy is set.

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

0 picks the number from the run's memory: one page per GB, which was the cheapest setting measured on Apify.

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

Usually not needed. Use it for sites that block cloud servers. Apify's datacenter proxy (leave groups empty) and your own proxy URLs work. Residential, Unblocker and Google SERP proxies are not supported, because their traffic costs more than a screenshot.

## Actor input object example

```json
{
  "urls": [
    "https://apify.com",
    "https://en.wikipedia.org/wiki/Web_scraping"
  ],
  "devices": [
    "desktop"
  ],
  "fullPage": true,
  "format": "png",
  "jpegQuality": 80,
  "pixelRatio": "auto",
  "colorScheme": "light",
  "hideCookieBanners": true,
  "blockAds": true,
  "scrollToLoad": true,
  "waitUntil": "load",
  "delayMs": 0,
  "maxHeight": 15000,
  "viewportWidth": 1440,
  "viewportHeight": 900,
  "pdfPaper": "A4",
  "captureErrorPages": false,
  "navigationTimeoutSecs": 45,
  "maxRetries": 2,
  "maxConcurrency": 0,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

The dataset rows this run produced.

## `runSummary` (type: `string`):

Counts, costs and anything skipped, saved as RUN_SUMMARY.

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

Files saved in the run's key-value store; each dataset row links to its own.

# 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/Web_scraping"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

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

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

```

## MCP server setup

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