# Full Page Screenshot & URL to PDF: Bulk Website Screenshot (`rowsmithhq/website-screenshot-pdf-snapshotter`) Actor

Full page screenshots and URL to PDF in bulk: $3 per 1,000, failed pages free. PNG, JPEG, WebP or PDF of any URL list or sitemap, on desktop, tablet and phone screens. Cookie banners hidden, ads blocked.

- **URL**: https://apify.com/rowsmithhq/website-screenshot-pdf-snapshotter.md
- **Developed by:** [Rowsmith HQ](https://apify.com/rowsmithhq) (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 $3.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 Screenshot & PDF Snapshotter: bulk full-page screenshots and URL to PDF

**Paste website links or a sitemap and get a clean screenshot or PDF of every page: $3.00 per 1,000 screenshots, all-in, and failed pages are free.**

Bulk website screenshots and URL to PDF in one tool. Capture the first screen or a full-page screenshot of any public webpage as an image (PNG, JPEG or WebP) or as a print-ready PDF, on desktop, laptop, tablet, iPhone and Android screens. Cookie banners, chat bubbles, ads and trackers are cleared away before every capture, so you get the page, not the clutter.

### At a glance

| | |
|---|---|
| **What it does** | Takes screenshots (PNG, JPEG or WebP) or PDFs of public web pages in bulk, from a list of links or a sitemap |
| **Good for** | Archiving and monitoring websites, SEO and design reviews, compliance records, visual QA, image datasets of websites |
| **Screens** | Desktop, laptop, tablet, iPhone and Android sizes, or any custom size |
| **Price** | $3.00 per 1,000 screenshots, all-in (no usage costs on top); failed pages are free |
| **Speed** | About 3-8 seconds per page in our tests, many pages at once |
| **Limits** | Public pages only (no logins); full-page images up to 15,000 px tall by default |
| **Made by** | Rowsmith HQ |
| **Last updated** | October 2026 |

### See the output

Real files from our test runs (python.org, MDN Web Docs, books.toscrape.com, a practice site for scrapers, and Wikipedia):

| Desktop, first screen (1440 x 900) | iPhone, first screen (393 x 852 at 2x) |
|---|---|
| ![Desktop first-screen screenshot of python.org](https://api.apify.com/v2/key-value-stores/yLDdJFUdIMOJ6RT3F/records/website-snapshotter--desktop-first-screen_python-org-png) | ![iPhone screenshot of an MDN Web Docs page](https://api.apify.com/v2/key-value-stores/yLDdJFUdIMOJ6RT3F/records/website-snapshotter--iphone-first-screen_mdn-html-png) |
| **Full-page screenshot, lazy images loaded** | **A4 PDF, page 1 of 52** |
| ![Full-page screenshot of books.toscrape.com](https://api.apify.com/v2/key-value-stores/yLDdJFUdIMOJ6RT3F/records/website-snapshotter--desktop-full-page_books-toscrape-com-png) | ![First page of an A4 PDF of a Wikipedia article](https://api.apify.com/v2/key-value-stores/yLDdJFUdIMOJ6RT3F/records/website-snapshotter--a4-pdf-page-1_wikipedia-history-of-the-internet-png) |

### What you get

- **One file per page, per device, per format.** PNG (sharpest), JPEG or WebP (much smaller), and/or a PDF (A4, Letter, Legal, A3 or Tabloid).
- **A results table** with one row per file: a direct download link, the page title, HTTP status, final URL after redirects, pixel size or PDF page count, file size, load time, and a plain-English error for any page that failed.
- **All files in the run's key-value store**, ready to download in Apify Console or fetch through the Apify API.
- **A run summary** (the `OUTPUT` record): files saved, files failed, charged events, and why the run stopped if it stopped early.

### Why use this one

- **Cookie banners hidden.** It clicks the banner's accept button on common consent tools (OneTrust, Cookiebot, Didomi, Quantcast, Usercentrics and many more), then hides any consent box that is left.
- **Ads and trackers blocked, so pages are clean and fast.** Well-known ad, analytics and tracking services are stopped inside the browser, and videos are skipped (their cover image shows instead). In our tests on five heavy pages (news sites, brand sites and a long article), this cut the data downloaded per page from 5.2 MB to 2.8 MB and the browser's work by about 40%. You can switch both off.
- **Lazy images loaded on full pages.** Before a full-page capture it scrolls to the bottom and back and waits for images, so you get pictures instead of grey boxes. Long pages are captured in screen-sized slices and joined, so very long pages do not freeze the browser.
- **Phone, tablet and desktop presets.** Desktop (1440 x 900), Full HD (1920 x 1080), laptop (1366 x 768), iPad (820 x 1180), iPhone (393 x 852), Android (412 x 915), or any custom size. Phone and tablet presets load the real mobile layout (mobile screen size, touch, mobile browser identity) at Retina sharpness.
- **Sitemap input.** Give it a `sitemap.xml`, a sitemap index or a `.xml.gz` file and it captures the pages listed, up to the limit you set. You can also paste many URLs at once or link to a text file of URLs.
- **A clear error for every URL that fails,** for example *"Domain not found: the DNS lookup failed. Check the URL for typos."* Temporary problems (timeouts, dropped connections) are retried automatically; permanent ones (unknown domain, a link that downloads a file, a bot-protection wall) are not, so dead links do not waste time.
- **Failed captures are free.** You are charged only after a file is saved.
- **No extra usage costs.** The prices below are the whole price. You do not pay Apify compute or data transfer on top.
- **Your budget is respected.** Set a maximum cost for the run and it stops cleanly before going over.

### How we compare

The five most used screenshot tools in the Apify Store charge Apify usage (no fixed price), $0.89, $4, $6 and $10 per 1,000 screenshots (22 October 2026). A plain picture of the first screen is cheap anywhere; tools differ in what you get back from long, heavy, real pages. Questions worth asking any of them:

| Ask any screenshot tool | This tool |
|---|---|
| Full-page shots: real images further down, or grey boxes? | **Real images.** It scrolls the page first and waits for lazy images to load |
| How tall can a full page be? | **Up to 100,000 px**, taken in slices so very long pages do not freeze the browser |
| A whole website from its sitemap? | **Yes**: sitemap, sitemap index or `.xml.gz`, up to 50,000 pages a run |
| Screenshots and PDFs of the same pages, on several devices, in one run? | **Yes**: PNG, JPEG, WebP and PDF; desktop, laptop, tablet, iPhone and Android |
| Cookie banners, chat bubbles and ads? | **Cleared**: banners accepted or hidden, chat bubbles hidden, ads and trackers blocked |
| Phone sizes in the real mobile layout? | **Yes**: mobile screen, touch and browser identity, at Retina sharpness |
| Pay for pages that fail? Learn why they failed? | **No charge**, and a plain-English reason for every failed URL |
| A fixed price, and a spending cap? | **$3 per 1,000**, nothing on top; a run stops cleanly before your cap |
| An answer when something goes wrong? | **Yes**: open an issue on the Issues tab and we reply there |

### Pricing

Pay only for files you get.

| What you get | Price | Per 1,000 |
|---|---|---|
| **Screenshot:** one image (the first screen, or the first 5,000 px of a full page) | $0.003 | **$3.00** |
| **Full-page extra height:** each further 5,000 px of a full-page image | $0.002 | $2.00 |
| **PDF:** one file of up to 10 pages | $0.004 | **$4.00** |
| **PDF extra pages:** each further 10 pages | $0.002 | $2.00 |
| A page that fails | free | free |

Worked examples:

- 1,000 first-screen screenshots (any device, any image format) = **$3.00**
- 1,000 full-page screenshots of pages up to 5,000 px tall = **$3.00**
- One full-page screenshot of a 12,000 px tall page = $0.003 + 2 x $0.002 = **$0.007**
- 1,000 PDFs of up to 10 pages = **$4.00**
- One 52-page article as a PDF = $0.004 + 5 x $0.002 = **$0.014**
- 500 URLs on desktop and iPhone, first screen, PNG = 1,000 files = **$3.00**
- The same page as a PNG and a PDF = $0.003 + $0.004 = **$0.007**

Good to know:

- Every format and every device is its own file. Two formats or two devices means two files.
- Height is measured the way the page is laid out (CSS pixels), not in image pixels, so sharp 2x phone images are not charged double.
- Apify adds its standard run-start fee of $0.00005 per GB of memory, which is $0.0001 for a default 2 GB run (a thirtieth of one screenshot).

### How to use it

1. Paste your URLs into **Website URLs**, or add a sitemap under **Sitemap URLs**.
2. Pick **Output formats** and **Devices**. Turn on **Capture the full page** if you want the whole page from top to bottom.
3. Click **Start**. Open the **Files** or **Image previews** tab of the results to see and download every file.

The defaults suit most sites: a PNG of the first screen on a desktop, with cookie banners and chat bubbles hidden and ads, trackers and videos blocked.

### Input

Example: two pages, as PNG and PDF, on desktop and iPhone, full page.

```json
{
  "startUrls": [
    { "url": "https://www.python.org" },
    { "url": "https://books.toscrape.com/" }
  ],
  "formats": ["png", "pdf"],
  "devices": ["desktop", "iphone"],
  "fullPage": true
}
```

Example: the first 200 pages of a sitemap as Full HD JPEG images.

```json
{
  "sitemapUrls": ["https://crawlee.dev/sitemap.xml"],
  "maxUrlsFromSitemaps": 200,
  "formats": ["jpeg"],
  "devices": ["desktopHd"]
}
```

| Option | What it does | Default |
|---|---|---|
| `startUrls` | Pages to capture. Paste many at once, upload a text file, or link to one. Links without `https://` get it added. | |
| `sitemapUrls`, `maxUrlsFromSitemaps` | Capture the pages listed in sitemaps, up to this many pages. | 100 pages |
| `formats` | `png`, `jpeg`, `webp`, `pdf` (one or more). | `png` |
| `devices` | `desktop`, `desktopHd`, `laptop`, `tablet`, `iphone`, `android`, `custom` (one or more). | `desktop` |
| `fullPage` | Whole page (on) or first screen only (off). | off |
| `maxPageHeight` | Full-page images stop at this height; the row says when an image was cut. Up to 100,000 px. | 15,000 px |
| `waitUntil`, `waitForSelector`, `delaySecs` | When to take the picture: page loaded, network idle or HTML ready; wait for an element; extra delay. | page loaded, 1 s |
| `hideCookieBanners`, `hideChatWidgets` | Clear cookie banners and live-chat bubbles. | on |
| `blockAds`, `blockMedia` | Block ads and trackers; skip videos. | on |
| `hideSelectors` | Anything else to remove, as CSS selectors (for example `.newsletter-popup`). | |
| `skipErrorPages` | Treat pages that answer with an HTTP error (like 404) as failed and free, instead of capturing them. | off |
| `deviceScaleFactor`, `imageQuality` | Pixel density (auto, 1x, 2x, 3x); JPEG and WebP quality. | auto, 80 |
| `pdfFormat`, `pdfLandscape`, `pdfMedia`, `pdfPrintBackground`, `pdfMarginMm` | Paper size, orientation, print or screen look, backgrounds, margins. | A4, portrait, print, on, 10 mm |
| `maxConcurrency`, `pageTimeoutSecs`, `maxRetries` | Pages at the same time (lowered automatically to fit the run's memory), page timeout, retries. | 10, 60 s, 2 |

### Output

One row per file. A saved screenshot:

```json
{
  "url": "https://www.python.org",
  "finalUrl": "https://www.python.org/",
  "status": "success",
  "error": null,
  "httpStatus": 200,
  "title": "Welcome to Python.org",
  "device": "desktop",
  "viewport": "1440x900",
  "scaleFactor": 1,
  "format": "png",
  "fullPage": false,
  "fileKey": "python-org-4863eab2-desktop.png",
  "fileUrl": "https://api.apify.com/v2/key-value-stores/<store-id>/records/python-org-4863eab2-desktop.png",
  "fileSizeBytes": 157399,
  "width": 1440,
  "height": 900,
  "pdfPages": null,
  "truncated": false,
  "chargedEvents": { "screenshot": 1 },
  "loadTimeMs": 1062,
  "durationMs": 5203,
  "attempts": 1,
  "warnings": [],
  "capturedAt": "2026-10-21T04:07:05+00:00"
}
```

A page that failed (nothing charged; some fields left out here):

```json
{
  "url": "https://no-such-site.rowsmith-test.invalid/",
  "status": "failed",
  "error": "Domain not found: the DNS lookup failed. Check the URL for typos. [ERR_NAME_NOT_RESOLVED]",
  "device": "desktop",
  "format": "png",
  "fileUrl": null,
  "chargedEvents": {},
  "attempts": 1
}
```

### FAQ

**Do I pay for pages that fail?**
No. A capture is charged only after its file is saved. Failed rows stay in the results with the reason, at no cost.

**Do I pay Apify usage on top?**
No. The event prices are the whole price; the only other charge is Apify's standard run-start fee ($0.0001 for a default run). Giving the run more memory makes it capture more pages at once without changing the price per file.

**How do I download the files?**
Every row has a `fileUrl` link. All files are also in the run's key-value store (the Storage tab in Apify Console), and you can fetch them with the Apify API.

**Can it capture pages behind a login, or get past CAPTCHAs?**
No. It captures public pages. A page that shows a bot-protection check is reported as failed, so you are not charged for a picture of a CAPTCHA.

**A popup still shows in my screenshot. What can I do?**
Cookie banners are hidden on a best-effort basis, and some sites use unusual consent boxes or their own promotions. Add the element's CSS selector to **Hide these elements** and it is removed before the capture.

**Is a 404 page charged?**
By default the page is captured as it looks (some people want exactly that) and charged like any other file. Turn on **Skip error pages** to treat HTTP errors as failed and free.

**How tall can a full-page screenshot be?**
15,000 px by default, up to 100,000 px. When a page is taller, the image stops there and the row says so (`truncated: true`). WebP images cannot be taller than 16,383 px, a limit of the format; use PNG or JPEG for very long pages.

**My page draws charts or loads content late. How do I get it all?**
Set **Wait until** to *Network idle*, add **Wait for this element** with a CSS selector of the late content, or add a few seconds of **Extra delay**.

**Can I run it on a schedule or from my own code?**
Yes. Like any Apify Actor, it runs from Apify Console, the Apify API, schedules and Apify's integrations.

### Limits

- Public pages only: no logins, and no getting past bot protection.
- Full-page images: up to 100,000 px tall (15,000 px by default). WebP: up to 16,383 px.
- Custom screen size: 240 to 3,840 px wide, 240 to 2,160 px tall.
- Sitemaps: up to 50,000 pages per run.
- Page timeout: 10 to 180 seconds (60 by default). Retries: 0 to 3 (2 by default).
- Cookie-banner hiding is best effort. If a box remains, hide it with a CSS selector.

### About

Built and maintained by **Rowsmith HQ**. If a site does not capture well, open an issue on the Issues tab with the URL and your settings, and we will look at it.

More from Rowsmith HQ:

- [SEO Site Audit with Excel Report](https://apify.com/rowsmithhq/seo-site-audit): a whole website checked for broken links and SEO problems, with a health score and the top fixes, $4 per 1,000 pages.
- [Career Board Job Feed](https://apify.com/rowsmithhq/career-board-job-feed): every open job of the companies you choose, from six hiring systems, in one table, $1 per 1,000 jobs.
- [Broken Link Checker & Sitemap Checker](https://apify.com/rowsmithhq/sitemap-broken-link-checker): every URL of a sitemap, a list or a page's links, with status, redirect chains and soft 404s in an Excel report, $0.20 per 1,000 URLs.

# Actor input Schema

## `startUrls` (type: `array`):

The pages to capture, one per line. You can paste many at once, upload a text file, or link to a text file of URLs. Links without http(s):// get https:// added.

## `sitemapUrls` (type: `array`):

Capture the pages listed in a sitemap, e.g. https://example.com/sitemap.xml. Sitemap index files and .xml.gz files work too. Limited by 'Max pages from sitemaps'.

## `maxUrlsFromSitemaps` (type: `integer`):

Stop reading sitemaps after this many pages. Links you paste directly are always all captured.

## `formats` (type: `array`):

Pick one or more. Each format is a separate file (and a separate charge). PNG is sharpest, JPEG and WebP are much smaller, PDF gives a printable document.

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

Each page is captured on every device you pick. Phone and tablet presets load the real mobile layout (mobile screen size, touch, mobile browser identity).

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

Off (default): only the first screen, exactly what a visitor sees before scrolling. On: the whole page from top to bottom, with lazy-loaded images scrolled into view. A full-page image includes the first 5,000 px of height; each further 5,000 px is charged as one extra-height event.

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

'Page loaded' suits most sites. 'Network idle' waits until the page stops downloading (best for heavy JavaScript apps and charts). 'HTML ready' is fastest.

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

Optional. Wait until this element is visible before capturing, e.g. #main-chart or .product-grid. If it never appears, the page is still captured with a warning.

## `delaySecs` (type: `integer`):

Extra seconds to wait after loading, for animations or late content.

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

Scrolls to the bottom and back before capturing, so lazy-loaded images and scroll animations appear in the full-page image instead of blank boxes.

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

Best effort: clicks the banner's accept button (OneTrust, Cookiebot, Didomi, Quantcast, Usercentrics and many more), then hides any consent box that is left.

## `hideChatWidgets` (type: `boolean`):

Hides floating chat buttons and windows (Intercom, HubSpot, Drift, Zendesk, Tidio, Crisp and others).

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

Stops well-known ad, analytics and tracking services from loading, so pages load faster and the image shows the page's own content. The site you capture is never blocked itself. Turn off to see the page exactly as a visitor without an ad blocker does.

## `blockMedia` (type: `boolean`):

Skips video and audio downloads; a background video shows its cover image instead. Faster captures. A link that points straight to a video file is not blocked.

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

Optional. Anything else to remove before capturing, one CSS selector per line, e.g. .newsletter-popup or #promo-bar.

## `skipErrorPages` (type: `boolean`):

Off: pages that answer with an HTTP error (like 404) are captured as they look. On: they are reported as failed instead, and not charged.

## `deviceScaleFactor` (type: `string`):

Auto: 1x for desktop and laptop, 2x (Retina sharp) for tablet and phones. Higher density means sharper but larger images.

## `imageQuality` (type: `integer`):

1-100. Higher is sharper with bigger files. Not used for PNG.

## `maxPageHeight` (type: `integer`):

Full-page images stop at this height (in screen pixels before density), so endless pages cannot produce giant files. The result row says when an image was cut.

## `customWidth` (type: `integer`):

Used only when 'Custom size' is chosen in Devices.

## `customHeight` (type: `integer`):

Used only when 'Custom size' is chosen in Devices. For full-page captures this is only the first screen's height.

## `customIsMobile` (type: `boolean`):

Turn on to get the mobile layout at your custom size (touch screen, mobile browser identity).

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

Page size of the PDF.

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

Wide pages instead of tall pages.

## `pdfPrintBackground` (type: `boolean`):

Keeps the site's colors and background images in the PDF.

## `pdfMedia` (type: `string`):

'Print version' uses the site's own print styles, like a browser's Save as PDF. 'Screen version' keeps the page looking like the website.

## `pdfMarginMm` (type: `integer`):

Blank border on every side of each PDF page.

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

The most pages captured in parallel. The run lowers it automatically to what its memory and CPU can handle (for example 2 at the default 2 GB of memory, 4 at 4 GB), so it never crashes or queues up pages for nothing.

## `pageTimeoutSecs` (type: `integer`):

How long to wait for a page to load before giving up on that attempt.

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

Pages that fail for a temporary reason (timeout, connection reset) are tried again, waiting a bit longer each time. Permanent problems (unknown domain, file download links, bot walls) are not retried.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.python.org"
    },
    {
      "url": "https://books.toscrape.com/"
    }
  ],
  "sitemapUrls": [
    "https://crawlee.dev/sitemap.xml"
  ],
  "maxUrlsFromSitemaps": 100,
  "formats": [
    "png"
  ],
  "devices": [
    "desktop"
  ],
  "fullPage": false,
  "waitUntil": "load",
  "delaySecs": 1,
  "scrollPage": true,
  "hideCookieBanners": true,
  "hideChatWidgets": true,
  "blockAds": true,
  "blockMedia": true,
  "skipErrorPages": false,
  "deviceScaleFactor": "auto",
  "imageQuality": 80,
  "maxPageHeight": 15000,
  "customWidth": 1280,
  "customHeight": 800,
  "customIsMobile": false,
  "pdfFormat": "A4",
  "pdfLandscape": false,
  "pdfPrintBackground": true,
  "pdfMedia": "print",
  "pdfMarginMm": 10,
  "maxConcurrency": 10,
  "pageTimeoutSecs": 60,
  "maxRetries": 2
}
```

# Actor output Schema

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

One row per screenshot or PDF: the page, device, format, a public link to the file, its size and whether it succeeded.

## `storage` (type: `string`):

The saved image and PDF files themselves, listed by key.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.python.org"
        },
        {
            "url": "https://books.toscrape.com/"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("rowsmithhq/website-screenshot-pdf-snapshotter").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 = { "startUrls": [
        { "url": "https://www.python.org" },
        { "url": "https://books.toscrape.com/" },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("rowsmithhq/website-screenshot-pdf-snapshotter").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 '{
  "startUrls": [
    {
      "url": "https://www.python.org"
    },
    {
      "url": "https://books.toscrape.com/"
    }
  ]
}' |
apify call rowsmithhq/website-screenshot-pdf-snapshotter --silent --output-dataset

```

## MCP server setup

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

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/CVhIDydeXlXQVqEOg/builds/VF85bVLJ0xxJjtbzq/openapi.json